diff --git a/.agents/skills/trigger-agents/SKILL.md b/.agents/skills/trigger-agents/SKILL.md
new file mode 100644
index 0000000..81666a9
--- /dev/null
+++ b/.agents/skills/trigger-agents/SKILL.md
@@ -0,0 +1,287 @@
+---
+name: trigger-agents
+description: AI agent patterns with Trigger.dev - orchestration, parallelization, routing, evaluator-optimizer, and human-in-the-loop. Use when building LLM-powered tasks that need parallel workers, approval gates, tool calling, or multi-step agent workflows.
+---
+
+# AI Agent Patterns with Trigger.dev
+
+Build production-ready AI agents using Trigger.dev's durable execution.
+
+## Pattern Selection
+
+```
+Need to...                              → Use
+─────────────────────────────────────────────────────
+Process items in parallel               → Parallelization
+Route to different models/handlers      → Routing
+Chain steps with validation gates       → Prompt Chaining
+Coordinate multiple specialized tasks   → Orchestrator-Workers
+Self-improve until quality threshold    → Evaluator-Optimizer
+Pause for human approval                → Human-in-the-Loop (waitpoints.md)
+Stream progress to frontend             → Realtime Streams (streaming.md)
+Let LLM call your tasks as tools        → ai.tool (ai-tool.md)
+```
+
+---
+
+## Core Patterns
+
+### 1. Prompt Chaining (Sequential with Gates)
+
+Chain LLM calls with validation between steps. Fail early if intermediate output is bad.
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+export const translateCopy = task({
+  id: "translate-copy",
+  run: async ({ text, targetLanguage, maxWords }) => {
+    // Step 1: Generate
+    const draft = await generateText({
+      model: openai("gpt-4o"),
+      prompt: `Write marketing copy about: ${text}`,
+    });
+
+    // Gate: Validate before continuing
+    const wordCount = draft.text.split(/\s+/).length;
+    if (wordCount > maxWords) {
+      throw new Error(`Draft too long: ${wordCount} > ${maxWords}`);
+    }
+
+    // Step 2: Translate (only if gate passed)
+    const translated = await generateText({
+      model: openai("gpt-4o"),
+      prompt: `Translate to ${targetLanguage}: ${draft.text}`,
+    });
+
+    return { draft: draft.text, translated: translated.text };
+  },
+});
+```
+
+---
+
+### 2. Routing (Classify → Dispatch)
+
+Use a cheap model to classify, then route to appropriate handler.
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { z } from "zod";
+
+const routingSchema = z.object({
+  model: z.enum(["gpt-4o", "o1-mini"]),
+  reason: z.string(),
+});
+
+export const routeQuestion = task({
+  id: "route-question",
+  run: async ({ question }) => {
+    // Cheap classification call
+    const routing = await generateText({
+      model: openai("gpt-4o-mini"),
+      messages: [
+        {
+          role: "system",
+          content: `Classify question complexity. Return JSON: {"model": "gpt-4o" | "o1-mini", "reason": "..."}
+          - gpt-4o: simple factual questions
+          - o1-mini: complex reasoning, math, code`,
+        },
+        { role: "user", content: question },
+      ],
+    });
+
+    const { model } = routingSchema.parse(JSON.parse(routing.text));
+
+    // Route to selected model
+    const answer = await generateText({
+      model: openai(model),
+      prompt: question,
+    });
+
+    return { answer: answer.text, routedTo: model };
+  },
+});
+```
+
+---
+
+### 3. Parallelization
+
+Run independent LLM calls simultaneously with `batch.triggerByTaskAndWait`.
+
+```typescript
+import { batch, task } from "@trigger.dev/sdk";
+
+export const analyzeContent = task({
+  id: "analyze-content",
+  run: async ({ text }) => {
+    // All three run in parallel
+    const { runs: [sentiment, summary, moderation] } = await batch.triggerByTaskAndWait([
+      { task: analyzeSentiment, payload: { text } },
+      { task: summarizeText, payload: { text } },
+      { task: moderateContent, payload: { text } },
+    ]);
+
+    // Check moderation first
+    if (moderation.ok && moderation.output.flagged) {
+      return { error: "Content flagged", reason: moderation.output.reason };
+    }
+
+    return {
+      sentiment: sentiment.ok ? sentiment.output : null,
+      summary: summary.ok ? summary.output : null,
+    };
+  },
+});
+```
+
+**See:** `references/orchestration.md` for advanced patterns
+
+---
+
+### 4. Orchestrator-Workers (Fan-out/Fan-in)
+
+Orchestrator extracts work items, fans out to workers, aggregates results.
+
+```typescript
+import { batch, task } from "@trigger.dev/sdk";
+
+export const factChecker = task({
+  id: "fact-checker",
+  run: async ({ article }) => {
+    // Step 1: Extract claims (sequential - need output first)
+    const { runs: [extractResult] } = await batch.triggerByTaskAndWait([
+      { task: extractClaims, payload: { article } },
+    ]);
+
+    if (!extractResult.ok) throw new Error("Failed to extract claims");
+    const claims = extractResult.output;
+
+    // Step 2: Fan-out - verify all claims in parallel
+    const { runs } = await batch.triggerByTaskAndWait(
+      claims.map(claim => ({ task: verifyClaim, payload: claim }))
+    );
+
+    // Step 3: Fan-in - aggregate results
+    const verified = runs
+      .filter((r): r is typeof r & { ok: true } => r.ok)
+      .map(r => r.output);
+
+    return { claims, verifications: verified };
+  },
+});
+```
+
+---
+
+### 5. Evaluator-Optimizer (Self-Refining Loop)
+
+Generate → Evaluate → Retry with feedback until approved.
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+
+export const refineTranslation = task({
+  id: "refine-translation",
+  run: async ({ text, targetLanguage, feedback, attempt = 0 }) => {
+    // Bail condition
+    if (attempt >= 5) {
+      return { text, status: "MAX_ATTEMPTS", attempts: attempt };
+    }
+
+    // Generate (with feedback if retrying)
+    const prompt = feedback
+      ? `Improve this translation based on feedback:\n${feedback}\n\nOriginal: ${text}`
+      : `Translate to ${targetLanguage}: ${text}`;
+
+    const translation = await generateText({
+      model: openai("gpt-4o"),
+      prompt,
+    });
+
+    // Evaluate
+    const evaluation = await generateText({
+      model: openai("gpt-4o"),
+      prompt: `Evaluate translation quality. Reply APPROVED or provide specific feedback:\n${translation.text}`,
+    });
+
+    if (evaluation.text.includes("APPROVED")) {
+      return { text: translation.text, status: "APPROVED", attempts: attempt + 1 };
+    }
+
+    // Recursive self-call with feedback
+    return refineTranslation.triggerAndWait({
+      text,
+      targetLanguage,
+      feedback: evaluation.text,
+      attempt: attempt + 1,
+    }).unwrap();
+  },
+});
+```
+
+---
+
+## Trigger-Specific Features
+
+| Feature | What it enables | Reference |
+|---------|-----------------|-----------|
+| **Waitpoints** | Human approval gates, external callbacks | `references/waitpoints.md` |
+| **Streams** | Real-time progress to frontend | `references/streaming.md` |
+| **ai.tool** | Let LLMs call your tasks as tools | `references/ai-tool.md` |
+| **batch.triggerByTaskAndWait** | Typed parallel execution | `references/orchestration.md` |
+
+---
+
+## Error Handling
+
+```typescript
+const { runs } = await batch.triggerByTaskAndWait([...]);
+
+// Check individual results
+for (const run of runs) {
+  if (run.ok) {
+    console.log(run.output);  // Typed output
+  } else {
+    console.error(run.error);  // Error details
+    console.log(run.taskIdentifier);  // Which task failed
+  }
+}
+
+// Or filter by task type
+const verifications = runs
+  .filter((r): r is typeof r & { ok: true } =>
+    r.ok && r.taskIdentifier === "verify-claim"
+  )
+  .map(r => r.output);
+```
+
+---
+
+## Quick Reference
+
+```typescript
+// Trigger and wait for result
+const result = await myTask.triggerAndWait(payload);
+if (result.ok) console.log(result.output);
+
+// Batch trigger same task
+const results = await myTask.batchTriggerAndWait([
+  { payload: item1 },
+  { payload: item2 },
+]);
+
+// Batch trigger different tasks (typed)
+const { runs } = await batch.triggerByTaskAndWait([
+  { task: taskA, payload: { foo: 1 } },
+  { task: taskB, payload: { bar: "x" } },
+]);
+
+// Self-recursion with unwrap
+return myTask.triggerAndWait(newPayload).unwrap();
+```
diff --git a/.agents/skills/trigger-agents/references/ai-tool.md b/.agents/skills/trigger-agents/references/ai-tool.md
new file mode 100644
index 0000000..8258afc
--- /dev/null
+++ b/.agents/skills/trigger-agents/references/ai-tool.md
@@ -0,0 +1,237 @@
+# ai.tool Integration
+
+Convert Trigger.dev tasks to Vercel AI SDK tools. Let LLMs call your tasks autonomously.
+
+## Basic Usage
+
+```typescript
+import { schemaTask, ai } from "@trigger.dev/sdk";
+import { generateText } from "ai";
+import { openai } from "@ai-sdk/openai";
+import { z } from "zod";
+
+// 1. Define task with schema
+const lookupWeather = schemaTask({
+  id: "lookup-weather",
+  schema: z.object({
+    location: z.string().describe("City name"),
+    units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
+  }),
+  run: async ({ location, units }) => {
+    const weather = await fetchWeather(location, units);
+    return { temperature: weather.temp, conditions: weather.conditions };
+  },
+});
+
+// 2. Convert to AI tool
+const weatherTool = ai.tool(lookupWeather);
+
+// 3. Use with AI SDK
+export const weatherAgent = schemaTask({
+  id: "weather-agent",
+  schema: z.object({ question: z.string() }),
+  run: async ({ question }) => {
+    const result = await generateText({
+      model: openai("gpt-4o"),
+      prompt: question,
+      tools: {
+        lookupWeather: weatherTool,
+      },
+    });
+
+    return { answer: result.text };
+  },
+});
+```
+
+---
+
+## Schema Requirements
+
+The task **must** use `schemaTask` with a Zod schema:
+
+```typescript
+// ✅ Works - has schema
+const myTask = schemaTask({
+  id: "my-task",
+  schema: z.object({
+    query: z.string(),
+  }),
+  run: async (payload) => { ... },
+});
+
+// ❌ Won't work - no schema
+const myTask = task({
+  id: "my-task",
+  run: async (payload: { query: string }) => { ... },
+});
+```
+
+**Supported schema libraries:**
+- Zod
+- ArkType
+- Any schema with `.toJsonSchema()` method
+
+---
+
+## Tool Result Customization
+
+Customize how results are sent back to the LLM:
+
+```typescript
+const searchTool = ai.tool(searchDatabase, {
+  experimental_toToolResultContent: (result) => {
+    // Return structured content for the LLM
+    return [
+      {
+        type: "text",
+        text: `Found ${result.count} results:\n${result.items.map(i => i.title).join("\n")}`,
+      },
+    ];
+  },
+});
+```
+
+---
+
+## Accessing Tool Options
+
+Get execution context inside the task:
+
+```typescript
+const myToolTask = schemaTask({
+  id: "my-tool-task",
+  schema: z.object({ input: z.string() }),
+  run: async (payload) => {
+    // Access AI SDK tool execution options
+    const toolOptions = ai.currentToolOptions();
+
+    console.log(toolOptions);
+    // { toolCallId: "...", messages: [...], ... }
+
+    return processInput(payload.input);
+  },
+});
+```
+
+---
+
+## Multiple Tools
+
+```typescript
+const searchTool = ai.tool(searchDatabase);
+const calculateTool = ai.tool(calculate);
+const summarizeTool = ai.tool(summarize);
+
+export const agentTask = schemaTask({
+  id: "agent",
+  schema: z.object({ task: z.string() }),
+  run: async ({ task }) => {
+    const result = await generateText({
+      model: openai("gpt-4o"),
+      prompt: task,
+      tools: {
+        search: searchTool,
+        calculate: calculateTool,
+        summarize: summarizeTool,
+      },
+      maxSteps: 10,  // Allow multiple tool calls
+    });
+
+    return { result: result.text };
+  },
+});
+```
+
+---
+
+## With Tool Choice
+
+```typescript
+const result = await generateText({
+  model: openai("gpt-4o"),
+  prompt: "What's the weather in Tokyo?",
+  tools: {
+    weather: weatherTool,
+    news: newsTool,
+  },
+  toolChoice: "required",  // Force tool use
+  // or: toolChoice: { type: "tool", toolName: "weather" }
+});
+```
+
+---
+
+## Description from Schema
+
+Add descriptions for better LLM understanding:
+
+```typescript
+const searchTask = schemaTask({
+  id: "search-database",
+  description: "Search the product database for items matching a query",
+  schema: z.object({
+    query: z.string().describe("Search terms"),
+    limit: z.number().min(1).max(100).describe("Max results to return"),
+    category: z.enum(["electronics", "clothing", "books"]).optional()
+      .describe("Filter by product category"),
+  }),
+  run: async (payload) => { ... },
+});
+```
+
+---
+
+## Common Pattern: Research Agent
+
+```typescript
+const webSearch = schemaTask({
+  id: "web-search",
+  schema: z.object({
+    query: z.string(),
+    maxResults: z.number().default(5),
+  }),
+  run: async ({ query, maxResults }) => {
+    return await searchWeb(query, maxResults);
+  },
+});
+
+const readUrl = schemaTask({
+  id: "read-url",
+  schema: z.object({
+    url: z.string().url(),
+  }),
+  run: async ({ url }) => {
+    return await fetchAndParse(url);
+  },
+});
+
+export const researchAgent = schemaTask({
+  id: "research-agent",
+  schema: z.object({ topic: z.string() }),
+  run: async ({ topic }) => {
+    const result = await generateText({
+      model: openai("gpt-4o"),
+      system: "Research the topic thoroughly using available tools.",
+      prompt: topic,
+      tools: {
+        search: ai.tool(webSearch),
+        read: ai.tool(readUrl),
+      },
+      maxSteps: 20,
+    });
+
+    return { research: result.text };
+  },
+});
+```
+
+---
+
+## Tips
+
+1. **Always use schemaTask** - regular `task` won't work
+2. **Add descriptions** - helps LLM understand when to use the tool
+3. **Use `.describe()`** - on schema fields for parameter hints
+4. **Set maxSteps** - allow multiple tool calls for complex tasks
+5. **Customize results** - use `experimental_toToolResultContent` for better LLM context
diff --git a/.agents/skills/trigger-agents/references/orchestration.md b/.agents/skills/trigger-agents/references/orchestration.md
new file mode 100644
index 0000000..c2524d2
--- /dev/null
+++ b/.agents/skills/trigger-agents/references/orchestration.md
@@ -0,0 +1,241 @@
+# Orchestration Patterns
+
+Advanced patterns for `batch.triggerByTaskAndWait` and task coordination.
+
+## Basic Usage
+
+```typescript
+import { batch, task } from "@trigger.dev/sdk";
+
+// Trigger different tasks, get typed results
+const { runs } = await batch.triggerByTaskAndWait([
+  { task: taskA, payload: { foo: "bar" } },  // payload typed to taskA
+  { task: taskB, payload: { num: 42 } },     // payload typed to taskB
+]);
+
+// Results are typed based on position
+if (runs[0].ok) {
+  console.log(runs[0].output);  // typed as taskA output
+}
+```
+
+## Destructured Results
+
+```typescript
+const {
+  runs: [userRun, postsRun, settingsRun],
+} = await batch.triggerByTaskAndWait([
+  { task: fetchUser, payload: { id } },
+  { task: fetchPosts, payload: { userId: id } },
+  { task: fetchSettings, payload: { userId: id } },
+]);
+
+// Each run is individually typed
+const user = userRun.ok ? userRun.output : null;
+const posts = postsRun.ok ? postsRun.output : [];
+```
+
+---
+
+## Error Handling Per-Task
+
+```typescript
+const { runs } = await batch.triggerByTaskAndWait([
+  { task: riskyTask, payload: item1 },
+  { task: riskyTask, payload: item2 },
+  { task: riskyTask, payload: item3 },
+]);
+
+// Individual error handling
+const results = runs.map(run => {
+  if (run.ok) {
+    return { success: true, data: run.output };
+  }
+  return {
+    success: false,
+    error: run.error,
+    taskId: run.taskIdentifier,
+    runId: run.id,
+  };
+});
+
+// Or throw if any failed
+const failed = runs.filter(r => !r.ok);
+if (failed.length > 0) {
+  throw new Error(`${failed.length} tasks failed`);
+}
+```
+
+---
+
+## Filtering by Task Identifier
+
+When running mixed task types, filter results by `taskIdentifier`:
+
+```typescript
+const { runs } = await batch.triggerByTaskAndWait([
+  ...claims.map(c => ({ task: verifySource, payload: c })),
+  ...claims.map(c => ({ task: analyzeHistory, payload: c })),
+]);
+
+// Filter to specific task results
+const verifications = runs
+  .filter((r): r is typeof r & { ok: true } =>
+    r.ok && r.taskIdentifier === "verify-source"
+  )
+  .map(r => r.output as SourceVerification);
+
+const analyses = runs
+  .filter((r): r is typeof r & { ok: true } =>
+    r.ok && r.taskIdentifier === "analyze-history"
+  )
+  .map(r => r.output as HistoricalAnalysis);
+```
+
+---
+
+## Fan-out/Fan-in Pattern
+
+```typescript
+export const processItems = task({
+  id: "process-items",
+  run: async ({ items }) => {
+    // Fan-out: process all items in parallel
+    const { runs } = await batch.triggerByTaskAndWait(
+      items.map(item => ({ task: processItem, payload: item }))
+    );
+
+    // Fan-in: aggregate results
+    const successful = runs.filter(r => r.ok).map(r => r.output);
+    const failed = runs.filter(r => !r.ok);
+
+    return {
+      processed: successful.length,
+      failed: failed.length,
+      results: successful,
+      errors: failed.map(f => ({ id: f.id, error: f.error })),
+    };
+  },
+});
+```
+
+---
+
+## Sequential Then Parallel
+
+```typescript
+export const orchestrator = task({
+  id: "orchestrator",
+  run: async ({ input }) => {
+    // Step 1: Sequential preprocessing
+    const { runs: [prepResult] } = await batch.triggerByTaskAndWait([
+      { task: preprocess, payload: { input } },
+    ]);
+
+    if (!prepResult.ok) {
+      throw new Error(`Preprocessing failed: ${prepResult.error}`);
+    }
+
+    const items = prepResult.output;
+
+    // Step 2: Parallel processing
+    const { runs } = await batch.triggerByTaskAndWait(
+      items.map(item => ({ task: processItem, payload: item }))
+    );
+
+    // Step 3: Sequential aggregation
+    const { runs: [aggResult] } = await batch.triggerByTaskAndWait([
+      { task: aggregate, payload: { results: runs.filter(r => r.ok).map(r => r.output) } },
+    ]);
+
+    return aggResult.ok ? aggResult.output : null;
+  },
+});
+```
+
+---
+
+## Same Task, Multiple Items
+
+For batch processing the same task:
+
+```typescript
+// Using batchTriggerAndWait (single task type)
+const results = await processItem.batchTriggerAndWait([
+  { payload: item1 },
+  { payload: item2 },
+  { payload: item3 },
+]);
+
+// Equivalent using batch.triggerByTaskAndWait
+const { runs } = await batch.triggerByTaskAndWait([
+  { task: processItem, payload: item1 },
+  { task: processItem, payload: item2 },
+  { task: processItem, payload: item3 },
+]);
+```
+
+---
+
+## Concurrency Control
+
+Control parallelism via queue settings on child tasks:
+
+```typescript
+import { queue, task } from "@trigger.dev/sdk";
+
+const rateLimitedQueue = queue({
+  name: "api-calls",
+  concurrencyLimit: 5,  // Max 5 concurrent
+});
+
+export const callExternalApi = task({
+  id: "call-external-api",
+  queue: rateLimitedQueue,
+  run: async (payload) => {
+    // Rate limited to 5 concurrent executions
+    return fetch(payload.url);
+  },
+});
+
+// Parent can batch trigger many - queue handles concurrency
+export const batchProcess = task({
+  id: "batch-process",
+  run: async ({ urls }) => {
+    // Will queue up, respecting concurrencyLimit: 5
+    return callExternalApi.batchTriggerAndWait(
+      urls.map(url => ({ payload: { url } }))
+    );
+  },
+});
+```
+
+---
+
+## Streaming Batch Items
+
+For large batches, stream items instead of loading all at once:
+
+```typescript
+import { batch } from "@trigger.dev/sdk";
+
+// Generator function for items
+async function* generateItems() {
+  for await (const record of database.cursor()) {
+    yield { task: processRecord, payload: record };
+  }
+}
+
+// Stream to batch trigger
+const { runs } = await batch.triggerByTaskAndWait(generateItems());
+```
+
+---
+
+## Tips
+
+1. **Use destructuring** for known task counts - cleaner code
+2. **Filter by taskIdentifier** when mixing task types
+3. **Check `.ok`** before accessing `.output`
+4. **Control concurrency** on child task queues, not in orchestrator
+5. **Avoid parallel waits** - use batch methods, not Promise.all with triggerAndWait
diff --git a/.agents/skills/trigger-agents/references/streaming.md b/.agents/skills/trigger-agents/references/streaming.md
new file mode 100644
index 0000000..15394e1
--- /dev/null
+++ b/.agents/skills/trigger-agents/references/streaming.md
@@ -0,0 +1,252 @@
+# Realtime Streams
+
+Stream data from tasks to your frontend in real-time. Perfect for AI completions, progress updates, and live status.
+
+## Define Streams
+
+Create typed stream definitions in a shared file:
+
+```typescript
+// trigger/streams.ts
+import { streams } from "@trigger.dev/sdk";
+
+// Define with type and unique ID
+export const progressStream = streams.define<string>({
+  id: "progress",
+});
+
+export const aiOutputStream = streams.define<string>({
+  id: "ai-output",
+});
+
+// Export type for frontend
+export type STREAMS = typeof progressStream | typeof aiOutputStream;
+```
+
+---
+
+## Emit from Tasks
+
+### Basic emit
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+import { progressStream } from "./streams";
+
+export const processItems = task({
+  id: "process-items",
+  run: async ({ items }) => {
+    for (const [i, item] of items.entries()) {
+      await processItem(item);
+
+      // Emit progress
+      progressStream.append(
+        JSON.stringify({
+          current: i + 1,
+          total: items.length,
+          status: `Processing ${item.name}`,
+        })
+      );
+    }
+
+    return { processed: items.length };
+  },
+});
+```
+
+### Stream AI completion
+
+```typescript
+import { task } from "@trigger.dev/sdk";
+import { streamText } from "ai";
+import { aiOutputStream } from "./streams";
+
+export const generateText = task({
+  id: "generate-text",
+  run: async ({ prompt }) => {
+    const result = streamText({
+      model: openai("gpt-4o"),
+      prompt,
+    });
+
+    // Pipe AI stream to Trigger stream
+    for await (const chunk of result.textStream) {
+      aiOutputStream.append(chunk);
+    }
+
+    return { text: await result.text };
+  },
+});
+```
+
+---
+
+## Child → Parent Streaming
+
+When child tasks need to emit to the parent's stream:
+
+```typescript
+// Child task
+export const workerTask = task({
+  id: "worker",
+  run: async ({ item }) => {
+    const result = await processItem(item);
+
+    // Emit to PARENT's stream, not this task's
+    progressStream.append(
+      JSON.stringify({ item: item.id, status: "done" }),
+      { target: "parent" }
+    );
+
+    return result;
+  },
+});
+
+// Parent task - frontend subscribes to this run
+export const orchestrator = task({
+  id: "orchestrator",
+  run: async ({ items }) => {
+    // Child emits bubble up to this task's stream
+    return workerTask.batchTriggerAndWait(
+      items.map(item => ({ payload: { item } }))
+    );
+  },
+});
+```
+
+---
+
+## Frontend Subscription
+
+### Using useRealtimeStream (Recommended)
+
+```tsx
+import { useRealtimeStream } from "@trigger.dev/react-hooks";
+import type { progressStream } from "@/trigger/streams";
+
+function Progress({ runId, accessToken }: { runId: string; accessToken: string }) {
+  const { data } = useRealtimeStream<typeof progressStream>(runId, {
+    accessToken,
+    stream: "progress",
+  });
+
+  if (!data) return <div>Waiting...</div>;
+
+  // data is array of emitted values
+  const latest = data[data.length - 1];
+  const progress = JSON.parse(latest);
+
+  return (
+    <div>
+      {progress.current} / {progress.total}: {progress.status}
+    </div>
+  );
+}
+```
+
+### Using useRealtimeRunWithStreams
+
+```tsx
+import { useRealtimeRunWithStreams } from "@trigger.dev/react-hooks";
+import type { processItems, STREAMS } from "@/trigger/tasks";
+
+function TaskProgress({ runId, accessToken }: Props) {
+  const { run, streams } = useRealtimeRunWithStreams<typeof processItems, STREAMS>(
+    runId,
+    { accessToken }
+  );
+
+  const progressUpdates = streams.progress ?? [];
+  const latest = progressUpdates[progressUpdates.length - 1];
+
+  return (
+    <div>
+      <p>Status: {run?.status}</p>
+      {latest && <p>Progress: {latest}</p>}
+    </div>
+  );
+}
+```
+
+---
+
+## Backend Consumption
+
+Read streams from your backend:
+
+```typescript
+import { aiOutputStream } from "./trigger/streams";
+
+async function consumeStream(runId: string) {
+  const stream = await aiOutputStream.read(runId, {
+    timeoutInSeconds: 120,
+  });
+
+  let fullText = "";
+  for await (const chunk of stream) {
+    fullText += chunk;
+    console.log("Received:", chunk);
+  }
+
+  return fullText;
+}
+```
+
+---
+
+## JSON Serialization Pattern
+
+Streams serialize as strings. For objects, use JSON:
+
+```typescript
+// Define helper functions
+export function emitProgress(update: ProgressUpdate, options?: { target: "parent" }) {
+  progressStream.append(JSON.stringify(update), options);
+}
+
+// Parse on frontend
+const updates = streams.progress?.map(s => JSON.parse(s) as ProgressUpdate) ?? [];
+```
+
+---
+
+## Throttling Frontend Updates
+
+Prevent excessive re-renders:
+
+```tsx
+const { data } = useRealtimeStream<typeof progressStream>(runId, {
+  accessToken,
+  stream: "progress",
+  throttleInMs: 100,  // Max 10 updates/second
+});
+```
+
+---
+
+## AI SDK Tool Calls
+
+Stream tool calls and results:
+
+```tsx
+const { streams } = useRealtimeRunWithStreams<typeof aiTask, STREAMS>(runId, {
+  accessToken,
+});
+
+// streams.openai is TextStreamPart[]
+const toolCalls = streams.openai?.filter(s => s.type === "tool-call") ?? [];
+const toolResults = streams.openai?.filter(s => s.type === "tool-result") ?? [];
+const textDeltas = streams.openai?.filter(s => s.type === "text-delta") ?? [];
+
+const fullText = textDeltas.map(d => d.textDelta).join("");
+```
+
+---
+
+## Tips
+
+1. **Use streams.define()** - always define in shared file for type safety
+2. **JSON stringify objects** - streams are strings internally
+3. **Use `{ target: "parent" }`** - for child-to-parent bubbling
+4. **Throttle on frontend** - prevent excessive re-renders
+5. **Set appropriate timeouts** - AI completions may need longer waits
diff --git a/.agents/skills/trigger-agents/references/waitpoints.md b/.agents/skills/trigger-agents/references/waitpoints.md
new file mode 100644
index 0000000..c3fb2ef
--- /dev/null
+++ b/.agents/skills/trigger-agents/references/waitpoints.md
@@ -0,0 +1,247 @@
+# Human-in-the-Loop with Waitpoints
+
+Pause task execution for human approval, external callbacks, or async events.
+
+## Core API
+
+```typescript
+import { wait } from "@trigger.dev/sdk";
+
+// Create a token (pauses execution point)
+const token = await wait.createToken({
+  timeout: "10m",  // "1h", "1d", etc.
+});
+
+// Wait for completion (blocks until resolved)
+const result = await wait.forToken<ApprovalPayload>(token.id);
+
+if (result.ok) {
+  console.log(result.output);  // Typed as ApprovalPayload
+} else {
+  console.log("Timed out:", result.error);
+}
+```
+
+---
+
+## Complete Pattern: Slack Approval
+
+```typescript
+import { task, wait } from "@trigger.dev/sdk";
+
+type ApprovalToken = {
+  approved: boolean;
+  selectedOption: "optionA" | "optionB";
+  approvedBy: string;
+};
+
+export const generateWithApproval = task({
+  id: "generate-with-approval",
+  maxDuration: 600,  // 10 min to account for human delay
+  run: async ({ prompt }) => {
+    // 1. Generate options
+    const options = await generateOptions(prompt);
+
+    // 2. Create approval token
+    const token = await wait.createToken({
+      timeout: "1h",
+    });
+
+    // 3. Send to Slack/email/webhook
+    await sendSlackMessage({
+      text: "Please approve one option:",
+      options,
+      approvalUrl: `${process.env.APP_URL}/approve?token=${token.id}`,
+      // Or use: token.url for direct callback
+    });
+
+    // 4. Wait for human (task suspends here)
+    const result = await wait.forToken<ApprovalToken>(token.id);
+
+    if (!result.ok) {
+      throw new Error("Approval timed out");
+    }
+
+    // 5. Continue with approved option
+    return {
+      selected: result.output.selectedOption,
+      approvedBy: result.output.approvedBy,
+      options,
+    };
+  },
+});
+```
+
+---
+
+## Completing Tokens
+
+### From your backend
+
+```typescript
+import { wait } from "@trigger.dev/sdk";
+
+// In your approval endpoint
+export async function POST(request: Request) {
+  const { tokenId, approved, option, userId } = await request.json();
+
+  await wait.completeToken<ApprovalToken>(tokenId, {
+    approved,
+    selectedOption: option,
+    approvedBy: userId,
+  });
+
+  return Response.json({ success: true });
+}
+```
+
+### Via HTTP callback (webhooks)
+
+```typescript
+const token = await wait.createToken({ timeout: "10m" });
+
+// token.url is a webhook URL that completes the token
+// POST to token.url with JSON body → becomes the output
+await externalService.startJob({
+  callbackUrl: token.url,  // Service POSTs result here
+});
+
+const result = await wait.forToken<ExternalResult>(token.id);
+```
+
+### From React (useWaitToken)
+
+```typescript
+import { useWaitToken } from "@trigger.dev/react-hooks";
+
+function ApprovalButton({ tokenId, publicToken }) {
+  const { complete, isCompleting } = useWaitToken(tokenId, {
+    accessToken: publicToken,
+  });
+
+  return (
+    <button
+      onClick={() => complete({ approved: true })}
+      disabled={isCompleting}
+    >
+      Approve
+    </button>
+  );
+}
+```
+
+---
+
+## Timeout Handling
+
+```typescript
+const result = await wait.forToken<ApprovalToken>(token.id);
+
+if (result.ok) {
+  // Human responded in time
+  return processApproval(result.output);
+} else {
+  // Timed out - handle gracefully
+  await notifyTimeout();
+  return { status: "timeout", defaultAction: "rejected" };
+}
+```
+
+### Using .unwrap() for cleaner code
+
+```typescript
+try {
+  const approval = await wait.forToken<ApprovalToken>(token.id).unwrap();
+  // approval is directly typed, throws on timeout
+  return processApproval(approval);
+} catch (error) {
+  // Timeout throws here
+  return handleTimeout();
+}
+```
+
+---
+
+## Idempotency
+
+Prevent duplicate tokens for the same workflow:
+
+```typescript
+const token = await wait.createToken({
+  timeout: "1h",
+  idempotencyKey: `review-${workflowId}`,
+});
+```
+
+---
+
+## Tags for Tracking
+
+```typescript
+const token = await wait.createToken({
+  timeout: "1h",
+  tags: [`workflow:${workflowId}`, `user:${userId}`],
+});
+```
+
+---
+
+## Public Access Token
+
+For frontend completion without server round-trip:
+
+```typescript
+const token = await wait.createToken({ timeout: "10m" });
+
+// Pass to frontend
+return {
+  tokenId: token.id,
+  publicToken: token.publicAccessToken,  // Auto-generated, expires in 1h
+};
+```
+
+---
+
+## Example: Multi-step Review
+
+```typescript
+export const contentPipeline = task({
+  id: "content-pipeline",
+  run: async ({ content }) => {
+    // Step 1: AI generation
+    const draft = await generateDraft(content);
+
+    // Step 2: Human review
+    const reviewToken = await wait.createToken({ timeout: "24h" });
+    await sendForReview(draft, reviewToken.id);
+    const review = await wait.forToken<ReviewResult>(reviewToken.id);
+
+    if (!review.ok || !review.output.approved) {
+      return { status: "rejected", feedback: review.output?.feedback };
+    }
+
+    // Step 3: Final approval
+    const publishToken = await wait.createToken({ timeout: "1h" });
+    await sendForPublishApproval(draft, publishToken.id);
+    const publish = await wait.forToken<PublishResult>(publishToken.id);
+
+    if (!publish.ok || !publish.output.approved) {
+      return { status: "not_published" };
+    }
+
+    // Step 4: Publish
+    await publishContent(draft);
+    return { status: "published" };
+  },
+});
+```
+
+---
+
+## Tips
+
+1. **Set realistic timeouts** - account for human response time
+2. **Handle timeouts gracefully** - don't throw, provide default behavior
+3. **Use idempotencyKey** - prevent duplicate tokens on retries
+4. **Increase maxDuration** - task needs enough time for human + processing
+5. **Use publicAccessToken** - for direct frontend completion
diff --git a/.agents/skills/trigger-config/SKILL.md b/.agents/skills/trigger-config/SKILL.md
new file mode 100644
index 0000000..f3764cc
--- /dev/null
+++ b/.agents/skills/trigger-config/SKILL.md
@@ -0,0 +1,240 @@
+---
+name: trigger-config
+description: Configure Trigger.dev projects with trigger.config.ts. Use when setting up build extensions for Prisma, Playwright, FFmpeg, Python, or customizing deployment settings.
+---
+
+# Trigger.dev Configuration
+
+Configure your Trigger.dev project with `trigger.config.ts` and build extensions.
+
+## When to Use
+
+- Setting up a new Trigger.dev project
+- Adding database support (Prisma, TypeORM)
+- Configuring browser automation (Playwright, Puppeteer)
+- Adding media processing (FFmpeg)
+- Running Python scripts from tasks
+- Syncing environment variables
+- Installing system packages
+
+## Basic Configuration
+
+```ts
+// trigger.config.ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "<project-ref>",
+  dirs: ["./trigger"],
+  runtime: "node", // "node", "node-22", or "bun"
+  logLevel: "info",
+
+  retries: {
+    enabledInDev: false,
+    default: {
+      maxAttempts: 3,
+      minTimeoutInMs: 1000,
+      maxTimeoutInMs: 10000,
+      factor: 2,
+    },
+  },
+
+  build: {
+    extensions: [], // Add extensions here
+  },
+});
+```
+
+## Common Build Extensions
+
+### Prisma
+
+```ts
+import { prismaExtension } from "@trigger.dev/build/extensions/prisma";
+
+export default defineConfig({
+  // ...
+  build: {
+    extensions: [
+      prismaExtension({
+        schema: "prisma/schema.prisma",
+        migrate: true,
+        directUrlEnvVarName: "DIRECT_DATABASE_URL",
+      }),
+    ],
+  },
+});
+```
+
+### Playwright (Browser Automation)
+
+```ts
+import { playwright } from "@trigger.dev/build/extensions/playwright";
+
+extensions: [
+  playwright({
+    browsers: ["chromium"], // or ["chromium", "firefox", "webkit"]
+  }),
+]
+```
+
+### Puppeteer
+
+```ts
+import { puppeteer } from "@trigger.dev/build/extensions/puppeteer";
+
+extensions: [puppeteer()]
+
+// Set env var: PUPPETEER_EXECUTABLE_PATH="/usr/bin/google-chrome-stable"
+```
+
+### FFmpeg (Media Processing)
+
+```ts
+import { ffmpeg } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  ffmpeg({ version: "7" }),
+]
+// Automatically sets FFMPEG_PATH and FFPROBE_PATH
+```
+
+### Python
+
+```ts
+import { pythonExtension } from "@trigger.dev/build/extensions/python";
+
+extensions: [
+  pythonExtension({
+    scripts: ["./python/**/*.py"],
+    requirementsFile: "./requirements.txt",
+    devPythonBinaryPath: ".venv/bin/python",
+  }),
+]
+
+// Usage in tasks:
+const result = await python.runScript("./python/process.py", ["arg1"]);
+```
+
+### System Packages (apt-get)
+
+```ts
+import { aptGet } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  aptGet({
+    packages: ["imagemagick", "curl"],
+  }),
+]
+```
+
+### Additional Files
+
+```ts
+import { additionalFiles } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  additionalFiles({
+    files: ["./assets/**", "./templates/**"],
+  }),
+]
+```
+
+### Environment Variable Sync
+
+```ts
+import { syncEnvVars } from "@trigger.dev/build/extensions/core";
+
+extensions: [
+  syncEnvVars(async (ctx) => {
+    return [
+      { name: "API_KEY", value: await getSecret(ctx.environment) },
+      { name: "ENV", value: ctx.environment },
+    ];
+  }),
+]
+```
+
+## Common Extension Combinations
+
+### Full-Stack Web App
+
+```ts
+extensions: [
+  prismaExtension({ schema: "prisma/schema.prisma", migrate: true }),
+  additionalFiles({ files: ["./assets/**"] }),
+  syncEnvVars(async (ctx) => [...envVars]),
+]
+```
+
+### AI/ML Processing
+
+```ts
+extensions: [
+  pythonExtension({
+    scripts: ["./ai/**/*.py"],
+    requirementsFile: "./requirements.txt",
+  }),
+  ffmpeg({ version: "7" }),
+]
+```
+
+### Web Scraping
+
+```ts
+extensions: [
+  playwright({ browsers: ["chromium"] }),
+  additionalFiles({ files: ["./selectors.json"] }),
+]
+```
+
+## Global Lifecycle Hooks
+
+```ts
+export default defineConfig({
+  // ...
+  onStartAttempt: async ({ payload, ctx }) => {
+    console.log("Task starting:", ctx.task.id);
+  },
+  onSuccess: async ({ payload, output, ctx }) => {
+    console.log("Task succeeded");
+  },
+  onFailure: async ({ payload, error, ctx }) => {
+    console.error("Task failed:", error);
+  },
+});
+```
+
+## Machine Defaults
+
+```ts
+export default defineConfig({
+  // ...
+  defaultMachine: "medium-1x",
+  maxDuration: 300, // seconds
+});
+```
+
+## Telemetry Integration
+
+```ts
+import { PrismaInstrumentation } from "@prisma/instrumentation";
+
+export default defineConfig({
+  // ...
+  telemetry: {
+    instrumentations: [new PrismaInstrumentation()],
+  },
+});
+```
+
+## Best Practices
+
+1. **Pin versions** for reproducible builds
+2. **Use `syncEnvVars`** for dynamic secrets
+3. **Add native modules** to `build.external` array
+4. **Debug with** `--log-level debug --dry-run`
+
+Extensions only affect deployment, not local development.
+
+See `references/config.md` for complete documentation.
diff --git a/.agents/skills/trigger-config/references/config.md b/.agents/skills/trigger-config/references/config.md
new file mode 100644
index 0000000..f6a4db1
--- /dev/null
+++ b/.agents/skills/trigger-config/references/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/.agents/skills/trigger-cost-savings/SKILL.md b/.agents/skills/trigger-cost-savings/SKILL.md
new file mode 100644
index 0000000..74efb32
--- /dev/null
+++ b/.agents/skills/trigger-cost-savings/SKILL.md
@@ -0,0 +1,158 @@
+---
+name: trigger-cost-savings
+description: Analyze Trigger.dev tasks, schedules, and runs for cost optimization opportunities. Use when asked to reduce spend, optimize costs, audit usage, right-size machines, or review task efficiency. Requires Trigger.dev MCP tools for run analysis.
+---
+
+# Trigger.dev Cost Savings Analysis
+
+Analyze task runs and configurations to find cost reduction opportunities.
+
+## Prerequisites: MCP Tools
+
+This skill requires the **Trigger.dev MCP server** to analyze live run data.
+
+### Check MCP availability
+
+Before analysis, verify these MCP tools are available:
+- `list_runs` — list runs with filters (status, task, time period, machine size)
+- `get_run_details` — get run logs, duration, and status
+- `get_current_worker` — get registered tasks and their configurations
+
+If these tools are **not available**, instruct the user:
+
+```
+To analyze your runs, you need the Trigger.dev MCP server installed.
+
+Run this command to install it:
+
+  npx trigger.dev@latest install-mcp
+
+This launches an interactive wizard that configures the MCP server for your AI client.
+```
+
+Do NOT proceed with run analysis without MCP tools. You can still review source code for static issues (see Static Analysis below).
+
+### Load latest cost reduction documentation
+
+Before giving recommendations, fetch the latest guidance:
+
+```
+WebFetch: https://trigger.dev/docs/how-to-reduce-your-spend
+```
+
+Use the fetched content to ensure recommendations are current. If the fetch fails, fall back to the reference documentation in `references/cost-reduction.md`.
+
+## Analysis Workflow
+
+### Step 1: Static Analysis (source code)
+
+Scan task files in the project for these issues:
+
+1. **Oversized machines** — tasks using `large-1x` or `large-2x` without clear need
+2. **Missing `maxDuration`** — tasks without execution time limits (runaway cost risk)
+3. **Excessive retries** — `maxAttempts` > 5 without `AbortTaskRunError` for known failures
+4. **Missing debounce** — high-frequency triggers without debounce configuration
+5. **Missing idempotency** — payment/critical tasks without idempotency keys
+6. **Polling instead of waits** — `setTimeout`/`setInterval`/sleep loops instead of `wait.for()`
+7. **Short waits** — `wait.for()` with < 5 seconds (not checkpointed, wastes compute)
+8. **Sequential instead of batch** — multiple `triggerAndWait()` calls that could use `batchTriggerAndWait()`
+9. **Over-scheduled crons** — schedules running more frequently than necessary
+
+### Step 2: Run Analysis (requires MCP tools)
+
+Use MCP tools to analyze actual usage patterns:
+
+#### 2a. Identify expensive tasks
+
+```
+list_runs with filters:
+- period: "30d" or "7d"
+- Sort by duration or cost
+- Check across different task IDs
+```
+
+Look for:
+- Tasks with high total compute time (duration x run count)
+- Tasks with high failure rates (wasted retries)
+- Tasks running on large machines with short durations (over-provisioned)
+
+#### 2b. Analyze failure patterns
+
+```
+list_runs with status: "FAILED" or "CRASHED"
+```
+
+For high-failure tasks:
+- Check if failures are retryable (transient) vs permanent
+- Suggest `AbortTaskRunError` for known non-retryable errors
+- Calculate wasted compute from failed retries
+
+#### 2c. Check machine utilization
+
+```
+get_run_details for sample runs of each task
+```
+
+Compare actual resource usage against machine preset:
+- If a task on `large-2x` consistently runs in < 1 second, it's over-provisioned
+- If tasks are I/O-bound (API calls, DB queries), they likely don't need large machines
+
+#### 2d. Review schedule frequency
+
+```
+get_current_worker to list scheduled tasks and their cron patterns
+```
+
+Flag schedules that may be too frequent for their purpose.
+
+### Step 3: Generate Recommendations
+
+Present findings as a prioritized list with estimated impact:
+
+```markdown
+## Cost Optimization Report
+
+### High Impact
+1. **Right-size `process-images` machine** — Currently `large-2x`, average run 2s.
+   Switching to `small-2x` could reduce this task's cost by ~16x.
+   ```ts
+   machine: { preset: "small-2x" }  // was "large-2x"
+   ```
+
+### Medium Impact
+2. **Add debounce to `sync-user-data`** — 847 runs/day, often triggered in bursts.
+   ```ts
+   debounce: { key: `user-${userId}`, delay: "5s" }
+   ```
+
+### Low Impact / Best Practices
+3. **Add `maxDuration` to `generate-report`** — No timeout configured.
+   ```ts
+   maxDuration: 300  // 5 minutes
+   ```
+```
+
+## Machine Preset Costs (relative)
+
+Larger machines cost proportionally more per second of compute:
+
+| Preset | vCPU | RAM | Relative Cost |
+|--------|------|-----|---------------|
+| micro | 0.25 | 0.25 GB | 0.25x |
+| small-1x | 0.5 | 0.5 GB | 1x (baseline) |
+| small-2x | 1 | 1 GB | 2x |
+| medium-1x | 1 | 2 GB | 2x |
+| medium-2x | 2 | 4 GB | 4x |
+| large-1x | 4 | 8 GB | 8x |
+| large-2x | 8 | 16 GB | 16x |
+
+## Key Principles
+
+- **Waits > 5 seconds are free** — checkpointed, no compute charge
+- **Start small, scale up** — default `small-1x` is right for most tasks
+- **I/O-bound tasks don't need big machines** — API calls, DB queries wait on network
+- **Debounce saves the most on high-frequency tasks** — consolidates bursts into single runs
+- **Idempotency prevents duplicate work** — especially important for expensive operations
+- **`AbortTaskRunError` stops wasteful retries** — don't retry permanent failures
+
+See `references/cost-reduction.md` for detailed strategies with code examples.
diff --git a/.agents/skills/trigger-cost-savings/references/cost-reduction.md b/.agents/skills/trigger-cost-savings/references/cost-reduction.md
new file mode 100644
index 0000000..012f7ec
--- /dev/null
+++ b/.agents/skills/trigger-cost-savings/references/cost-reduction.md
@@ -0,0 +1,206 @@
+# Cost Reduction Strategies
+
+Detailed strategies for reducing Trigger.dev spend. For the latest version, fetch:
+https://trigger.dev/docs/how-to-reduce-your-spend
+
+## 1. Monitor Usage
+
+Review your usage dashboard regularly to identify:
+- Most expensive tasks (by total compute time)
+- Run counts and daily spikes
+- Failure rates and wasted retries
+
+## 2. Configure Billing Alerts
+
+Set up alerts in the Trigger.dev dashboard:
+- **Standard alerts**: Notifications at 75%, 90%, 100%, 200%, 500% of budget
+- **Spike alerts**: Protection at 10x, 20x, 50x, 100x of monthly budget
+
+Keep spike alerts enabled as a safety net against runaway costs.
+
+## 3. Right-Size Machines
+
+Start with the smallest machine and scale only when necessary:
+
+```ts
+// Default (small-1x) is right for most tasks
+export const apiTask = task({
+  id: "call-api",
+  // No machine preset needed — defaults to small-1x
+  run: async (payload) => {
+    const response = await fetch("https://api.example.com/data");
+    return response.json();
+  },
+});
+
+// Only use larger machines for CPU/memory-intensive work
+export const imageProcessor = task({
+  id: "process-image",
+  machine: { preset: "medium-1x" }, // Only if actually needed
+  run: async (payload) => {
+    // Heavy image processing that needs more RAM
+  },
+});
+
+// Override machine at trigger time for variable workloads
+await imageProcessor.trigger(largePayload, {
+  machine: { preset: "large-1x" }, // Larger only for this specific run
+});
+```
+
+## 4. Use Idempotency Keys
+
+Prevent duplicate execution of expensive operations:
+
+```ts
+import { task, idempotencyKeys } from "@trigger.dev/sdk";
+
+export const expensiveTask = task({
+  id: "expensive-operation",
+  run: async (payload: { orderId: string }) => {
+    const key = await idempotencyKeys.create(`order-${payload.orderId}`);
+
+    // This won't re-execute if triggered again with same key
+    await costlyChildTask.trigger(payload, {
+      idempotencyKey: key,
+      idempotencyKeyTTL: "24h",
+    });
+  },
+});
+```
+
+## 5. Parallelize Within Tasks
+
+Consolidate multiple async operations into single tasks instead of spawning many:
+
+```ts
+// Expensive: 3 separate task runs
+await taskA.triggerAndWait(data);
+await taskB.triggerAndWait(data);
+await taskC.triggerAndWait(data);
+
+// Cheaper: single task with parallel I/O (when work is I/O-bound)
+export const combinedTask = task({
+  id: "combined-api-calls",
+  run: async (payload) => {
+    const [a, b, c] = await Promise.all([
+      fetch("https://api-a.com"),
+      fetch("https://api-b.com"),
+      fetch("https://api-c.com"),
+    ]);
+    return { a: await a.json(), b: await b.json(), c: await c.json() };
+  },
+});
+```
+
+Note: Only use `Promise.all` for regular async operations (fetch, DB queries), NOT for `triggerAndWait()` or `wait.*` calls.
+
+## 6. Optimize Retries
+
+Reduce wasted compute from retries:
+
+```ts
+import { task, AbortTaskRunError } from "@trigger.dev/sdk";
+
+export const smartRetryTask = task({
+  id: "smart-retry",
+  retry: {
+    maxAttempts: 3, // Not 10 — be realistic
+  },
+  catchError: async ({ error }) => {
+    // Don't retry known permanent failures
+    if (error.message?.includes("NOT_FOUND")) {
+      throw new AbortTaskRunError("Resource not found — won't retry");
+    }
+    if (error.message?.includes("UNAUTHORIZED")) {
+      throw new AbortTaskRunError("Auth failed — won't retry");
+    }
+    // Only retry transient errors
+  },
+  run: async (payload) => {
+    // task logic
+  },
+});
+```
+
+## 7. Set maxDuration
+
+Prevent runaway tasks from consuming unlimited compute:
+
+```ts
+export const boundedTask = task({
+  id: "bounded-task",
+  maxDuration: 300, // 5 minutes max
+  run: async (payload) => {
+    // If this takes longer than 5 minutes, it's killed
+  },
+});
+```
+
+## 8. Use Waitpoints Instead of Polling
+
+Waits > 5 seconds are checkpointed and free:
+
+```ts
+// Expensive: polling loop burns compute
+export const pollingTask = task({
+  id: "polling-bad",
+  run: async (payload) => {
+    while (true) {
+      const status = await checkStatus(payload.id);
+      if (status === "ready") break;
+      await new Promise((r) => setTimeout(r, 5000)); // WASTES compute
+    }
+  },
+});
+
+// Free: checkpointed wait
+import { wait } from "@trigger.dev/sdk";
+
+export const waitTask = task({
+  id: "wait-good",
+  run: async (payload) => {
+    await wait.for({ minutes: 5 }); // FREE — checkpointed
+    const status = await checkStatus(payload.id);
+    if (status !== "ready") {
+      await wait.for({ minutes: 5 }); // Still free
+    }
+  },
+});
+```
+
+## 9. Debounce High-Frequency Triggers
+
+Consolidate bursts into single executions:
+
+```ts
+// Without debounce: 100 webhook events = 100 task runs
+await syncTask.trigger({ userId: "123" });
+
+// With debounce: 100 events in 5s = 1 task run
+await syncTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "sync-user-123",
+      delay: "5s",
+      mode: "trailing", // Use latest payload
+    },
+  }
+);
+```
+
+## Cost Checklist
+
+Use this checklist when reviewing tasks:
+
+- [ ] Machine preset matches actual resource needs (start with `small-1x`)
+- [ ] `maxDuration` is set to a reasonable limit
+- [ ] Retry `maxAttempts` is appropriate (not excessive)
+- [ ] `AbortTaskRunError` used for known permanent failures
+- [ ] Idempotency keys used for expensive/critical operations
+- [ ] `wait.for()` used instead of polling loops (with delays > 5s)
+- [ ] Debounce configured for high-frequency trigger sources
+- [ ] Batch triggering used instead of sequential `triggerAndWait()` loops
+- [ ] Scheduled task frequency matches actual business needs
+- [ ] Billing alerts configured in dashboard
diff --git a/.agents/skills/trigger-realtime/SKILL.md b/.agents/skills/trigger-realtime/SKILL.md
new file mode 100644
index 0000000..5368360
--- /dev/null
+++ b/.agents/skills/trigger-realtime/SKILL.md
@@ -0,0 +1,288 @@
+---
+name: trigger-realtime
+description: Subscribe to Trigger.dev task runs in real-time from frontend and backend. Use when building progress indicators, live dashboards, streaming AI/LLM responses, or React components that display task status.
+---
+
+# Trigger.dev Realtime
+
+Subscribe to task runs and stream data in real-time from frontend and backend.
+
+## When to Use
+
+- Building progress indicators for long-running tasks
+- Creating live dashboards showing task status
+- Streaming AI/LLM responses to the UI
+- React components that trigger and monitor tasks
+- Waiting for user approval in tasks
+
+## Authentication
+
+### Create Public Access Token (Backend)
+
+```ts
+import { auth } from "@trigger.dev/sdk";
+
+// Read-only token for specific runs
+const publicToken = await auth.createPublicToken({
+  scopes: {
+    read: {
+      runs: ["run_123"],
+      tasks: ["my-task"],
+    },
+  },
+  expirationTime: "1h",
+});
+
+// Pass this token to your frontend
+```
+
+### Create Trigger Token (for frontend triggering)
+
+```ts
+const triggerToken = await auth.createTriggerPublicToken("my-task", {
+  expirationTime: "30m",
+});
+```
+
+## Backend Subscriptions
+
+```ts
+import { runs, tasks } from "@trigger.dev/sdk";
+
+// Trigger and subscribe
+const handle = await tasks.trigger("my-task", { data: "value" });
+
+for await (const run of runs.subscribeToRun(handle.id)) {
+  console.log(`Status: ${run.status}`);
+  console.log(`Progress: ${run.metadata?.progress}`);
+  
+  if (run.status === "COMPLETED") {
+    console.log("Output:", run.output);
+    break;
+  }
+}
+
+// Subscribe to tagged runs
+for await (const run of runs.subscribeToRunsWithTag("user-123")) {
+  console.log(`Run ${run.id}: ${run.status}`);
+}
+
+// Subscribe to batch
+for await (const run of runs.subscribeToBatch(batchId)) {
+  console.log(`Batch run ${run.id}: ${run.status}`);
+}
+```
+
+## React Hooks
+
+### Installation
+
+```bash
+npm add @trigger.dev/react-hooks
+```
+
+### Trigger Task from React
+
+```tsx
+"use client";
+import { useRealtimeTaskTrigger } from "@trigger.dev/react-hooks";
+import type { myTask } from "../trigger/tasks";
+
+function TaskTrigger({ accessToken }: { accessToken: string }) {
+  const { submit, run, isLoading } = useRealtimeTaskTrigger<typeof myTask>(
+    "my-task",
+    { accessToken }
+  );
+
+  return (
+    <div>
+      <button 
+        onClick={() => submit({ data: "value" })} 
+        disabled={isLoading}
+      >
+        Start Task
+      </button>
+      
+      {run && (
+        <div>
+          <p>Status: {run.status}</p>
+          <p>Progress: {run.metadata?.progress}%</p>
+          {run.output && <p>Result: {JSON.stringify(run.output)}</p>}
+        </div>
+      )}
+    </div>
+  );
+}
+```
+
+### Subscribe to Existing Run
+
+```tsx
+"use client";
+import { useRealtimeRun } from "@trigger.dev/react-hooks";
+import type { myTask } from "../trigger/tasks";
+
+function RunStatus({ runId, accessToken }: { runId: string; accessToken: string }) {
+  const { run, error } = useRealtimeRun<typeof myTask>(runId, {
+    accessToken,
+    onComplete: (run) => {
+      console.log("Completed:", run.output);
+    },
+  });
+
+  if (error) return <div>Error: {error.message}</div>;
+  if (!run) return <div>Loading...</div>;
+
+  return (
+    <div>
+      <p>Status: {run.status}</p>
+      <p>Progress: {run.metadata?.progress || 0}%</p>
+    </div>
+  );
+}
+```
+
+### Subscribe to Tagged Runs
+
+```tsx
+"use client";
+import { useRealtimeRunsWithTag } from "@trigger.dev/react-hooks";
+
+function UserTasks({ userId, accessToken }: { userId: string; accessToken: string }) {
+  const { runs } = useRealtimeRunsWithTag(`user-${userId}`, { accessToken });
+
+  return (
+    <ul>
+      {runs.map((run) => (
+        <li key={run.id}>{run.id}: {run.status}</li>
+      ))}
+    </ul>
+  );
+}
+```
+
+## Realtime Streams (AI/LLM)
+
+### Define Stream (shared location)
+
+```ts
+// trigger/streams.ts
+import { streams } from "@trigger.dev/sdk";
+
+export const aiStream = streams.define<string>({
+  id: "ai-output",
+});
+```
+
+### Pipe Stream in Task
+
+```ts
+import { task } from "@trigger.dev/sdk";
+import { aiStream } from "./streams";
+
+export const streamingTask = task({
+  id: "streaming-task",
+  run: async (payload: { prompt: string }) => {
+    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();
+  },
+});
+```
+
+### Read Stream in React
+
+```tsx
+"use client";
+import { useRealtimeStream } from "@trigger.dev/react-hooks";
+import { aiStream } from "../trigger/streams";
+
+function AIResponse({ runId, accessToken }: { runId: string; accessToken: string }) {
+  const { parts, error } = useRealtimeStream(aiStream, runId, {
+    accessToken,
+    throttleInMs: 50,
+  });
+
+  if (error) return <div>Error: {error.message}</div>;
+  if (!parts) return <div>Waiting for response...</div>;
+
+  return <div>{parts.join("")}</div>;
+}
+```
+
+## Wait Tokens (Human-in-the-loop)
+
+### In Task
+
+```ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const approvalTask = task({
+  id: "approval-task",
+  run: async (payload) => {
+    // Process initial data
+    const processed = await processData(payload);
+
+    // Wait for human approval
+    const approval = await wait.forToken<{ approved: boolean }>({
+      token: `approval-${payload.id}`,
+      timeoutInSeconds: 86400, // 24 hours
+    });
+
+    if (approval.approved) {
+      return await finalizeData(processed);
+    }
+    
+    throw new Error("Not approved");
+  },
+});
+```
+
+### Complete Token from React
+
+```tsx
+"use client";
+import { useWaitToken } from "@trigger.dev/react-hooks";
+
+function ApprovalButton({ tokenId, accessToken }: { tokenId: string; accessToken: string }) {
+  const { complete } = useWaitToken(tokenId, { accessToken });
+
+  return (
+    <div>
+      <button onClick={() => complete({ approved: true })}>
+        Approve
+      </button>
+      <button onClick={() => complete({ approved: false })}>
+        Reject
+      </button>
+    </div>
+  );
+}
+```
+
+## Run Object Properties
+
+| Property | Description |
+|----------|-------------|
+| `id` | Unique run identifier |
+| `status` | `QUEUED`, `EXECUTING`, `COMPLETED`, `FAILED`, `CANCELED` |
+| `payload` | Task input (typed) |
+| `output` | Task result (typed, when completed) |
+| `metadata` | Real-time updatable data |
+| `createdAt` | Start timestamp |
+| `costInCents` | Execution cost |
+
+## Best Practices
+
+1. **Scope tokens narrowly** — only grant necessary permissions
+2. **Set expiration times** — don't use long-lived tokens
+3. **Use typed hooks** — pass task types for proper inference
+4. **Handle errors** — always check for errors in hooks
+5. **Throttle streams** — use `throttleInMs` to control re-renders
+
+See `references/realtime.md` for complete documentation.
diff --git a/.agents/skills/trigger-realtime/references/realtime.md b/.agents/skills/trigger-realtime/references/realtime.md
new file mode 100644
index 0000000..c1c4c58
--- /dev/null
+++ b/.agents/skills/trigger-realtime/references/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/.agents/skills/trigger-setup/SKILL.md b/.agents/skills/trigger-setup/SKILL.md
new file mode 100644
index 0000000..9e30b4e
--- /dev/null
+++ b/.agents/skills/trigger-setup/SKILL.md
@@ -0,0 +1,127 @@
+---
+name: trigger-setup
+description: Set up Trigger.dev in your project. Use when adding Trigger.dev for the first time, creating trigger.config.ts, or initializing the trigger directory.
+---
+
+# Trigger.dev Setup
+
+Get Trigger.dev running in your project in minutes.
+
+## When to Use
+
+- Adding Trigger.dev to an existing project
+- Creating your first task
+- Setting up trigger.config.ts
+- Connecting to Trigger.dev cloud
+
+## Prerequisites
+
+- Node.js 18+ or Bun
+- A Trigger.dev account (https://cloud.trigger.dev)
+
+## Quick Start
+
+### 1. Install the SDK
+
+```bash
+npm install @trigger.dev/sdk
+```
+
+### 2. Initialize Your Project
+
+```bash
+npx trigger init
+```
+
+This creates:
+- `trigger.config.ts` - project configuration
+- `trigger/` directory - where your tasks live
+- `trigger/example.ts` - a sample task
+
+### 3. Configure trigger.config.ts
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "proj_xxxxx", // From dashboard
+  dirs: ["./trigger"],
+});
+```
+
+### 4. Create Your First Task
+
+```ts
+// trigger/my-task.ts
+import { task } from "@trigger.dev/sdk";
+
+export const myFirstTask = task({
+  id: "my-first-task",
+  run: async (payload: { name: string }) => {
+    console.log(`Hello, ${payload.name}!`);
+    return { message: `Processed ${payload.name}` };
+  },
+});
+```
+
+### 5. Start Development Server
+
+```bash
+npx trigger dev
+```
+
+### 6. Trigger Your Task
+
+From your app code:
+
+```ts
+import { tasks } from "@trigger.dev/sdk";
+import type { myFirstTask } from "./trigger/my-task";
+
+await tasks.trigger<typeof myFirstTask>("my-first-task", {
+  name: "World",
+});
+```
+
+Or from the Trigger.dev dashboard "Test" tab.
+
+## Project Structure
+
+```
+your-project/
+├── trigger.config.ts    # Required - project config
+├── trigger/             # Required - task files
+│   ├── my-task.ts
+│   └── another-task.ts
+├── package.json
+└── ...
+```
+
+## Environment Variables
+
+Create `.env` or set in your environment:
+
+```bash
+TRIGGER_SECRET_KEY=tr_dev_xxxxx  # From dashboard > API Keys
+```
+
+## Common Issues
+
+### "No tasks found"
+- Ensure tasks are **exported** from files in `dirs` folders
+- Check `trigger.config.ts` points to correct directories
+
+### "Project not found"
+- Verify `project` in config matches dashboard
+- Check `TRIGGER_SECRET_KEY` is set
+
+### "Task not registered"
+- Restart `npx trigger dev` after adding new tasks
+- Tasks must use `task()` or `schemaTask()` from `@trigger.dev/sdk`
+
+## Next Steps
+
+- Add retry logic → see **trigger-tasks** skill
+- Configure build extensions → see **trigger-config** skill
+- Build AI workflows → see **trigger-agents** skill
+- Add real-time UI → see **trigger-realtime** skill
diff --git a/.agents/skills/trigger-setup/references/environment-setup.md b/.agents/skills/trigger-setup/references/environment-setup.md
new file mode 100644
index 0000000..bf1293c
--- /dev/null
+++ b/.agents/skills/trigger-setup/references/environment-setup.md
@@ -0,0 +1,104 @@
+# Environment Setup
+
+## Required Variables
+
+| Variable | Description | Where to find |
+|----------|-------------|---------------|
+| `TRIGGER_SECRET_KEY` | API key for authentication | Dashboard > API Keys |
+
+## Development vs Production Keys
+
+```bash
+# Development (starts with tr_dev_)
+TRIGGER_SECRET_KEY=tr_dev_xxxxx
+
+# Production (starts with tr_prod_)
+TRIGGER_SECRET_KEY=tr_prod_xxxxx
+```
+
+## Local Development
+
+### Option 1: .env File
+
+```bash
+# .env
+TRIGGER_SECRET_KEY=tr_dev_xxxxx
+```
+
+Add to `.gitignore`:
+
+```
+.env
+.env.local
+```
+
+### Option 2: Shell Export
+
+```bash
+export TRIGGER_SECRET_KEY=tr_dev_xxxxx
+npx trigger dev
+```
+
+## CI/CD Deployment
+
+### GitHub Actions
+
+```yaml
+- name: Deploy Trigger.dev
+  env:
+    TRIGGER_SECRET_KEY: ${{ secrets.TRIGGER_SECRET_KEY }}
+  run: npx trigger deploy
+```
+
+### Vercel
+
+Add `TRIGGER_SECRET_KEY` in Project Settings > Environment Variables.
+
+### Other Platforms
+
+Set `TRIGGER_SECRET_KEY` in your platform's secret management.
+
+## Multi-Environment Setup
+
+Use different keys per environment:
+
+| Environment | Key Prefix | Dashboard Section |
+|-------------|------------|-------------------|
+| Development | `tr_dev_` | Dev environment |
+| Staging | `tr_stg_` | Staging environment |
+| Production | `tr_prod_` | Prod environment |
+
+## Task Environment Variables
+
+Tasks run in Trigger.dev's infrastructure. To use env vars in tasks:
+
+1. **Sync from local** (using `syncEnvVars` extension):
+
+```ts
+// trigger.config.ts
+import { defineConfig } from "@trigger.dev/sdk";
+import { syncEnvVars } from "@trigger.dev/build/extensions/core";
+
+export default defineConfig({
+  project: "proj_xxxxx",
+  build: {
+    extensions: [
+      syncEnvVars(),
+    ],
+  },
+});
+```
+
+2. **Set in dashboard**: Project Settings > Environment Variables
+
+3. **Access in tasks**:
+
+```ts
+export const myTask = task({
+  id: "my-task",
+  run: async () => {
+    const apiKey = process.env.EXTERNAL_API_KEY;
+    // ...
+  },
+});
+```
diff --git a/.agents/skills/trigger-setup/references/project-structure.md b/.agents/skills/trigger-setup/references/project-structure.md
new file mode 100644
index 0000000..2c73984
--- /dev/null
+++ b/.agents/skills/trigger-setup/references/project-structure.md
@@ -0,0 +1,94 @@
+# Project Structure
+
+## Default Layout
+
+```
+your-project/
+├── trigger.config.ts    # Required - project configuration
+├── trigger/             # Default task directory
+│   ├── example.ts       # Created by `npx trigger init`
+│   └── ...
+├── package.json
+└── src/                 # Your app code
+```
+
+## Monorepo Layout
+
+For monorepos, place `trigger.config.ts` in the package that contains your tasks:
+
+```
+monorepo/
+├── packages/
+│   ├── api/
+│   │   ├── trigger.config.ts  # Config here
+│   │   ├── trigger/           # Tasks here
+│   │   └── src/
+│   └── web/
+└── package.json
+```
+
+## Multiple Task Directories
+
+Configure multiple directories in `trigger.config.ts`:
+
+```ts
+import { defineConfig } from "@trigger.dev/sdk";
+
+export default defineConfig({
+  project: "proj_xxxxx",
+  dirs: [
+    "./trigger",           // Default
+    "./src/jobs",          // Additional
+    "./src/scheduled",     // Another
+  ],
+});
+```
+
+## Collocated Tasks
+
+Keep tasks next to related code:
+
+```
+src/
+├── users/
+│   ├── routes.ts
+│   └── tasks/
+│       └── send-welcome-email.ts
+├── orders/
+│   ├── routes.ts
+│   └── tasks/
+│       └── process-order.ts
+```
+
+```ts
+// trigger.config.ts
+export default defineConfig({
+  project: "proj_xxxxx",
+  dirs: ["./src/**/tasks"],  // Glob pattern
+});
+```
+
+## Task File Requirements
+
+Each task file must:
+
+1. **Export** tasks (named exports)
+2. Use `task()` or `schemaTask()` from `@trigger.dev/sdk`
+3. Have unique task IDs across all files
+
+```ts
+// ✅ Correct - exported task
+export const myTask = task({
+  id: "my-task",  // Unique ID
+  run: async (payload) => { ... },
+});
+
+// ❌ Wrong - not exported
+const privateTask = task({ ... });
+
+// ❌ Wrong - duplicate ID will error
+export const anotherTask = task({
+  id: "my-task",  // Conflicts!
+  run: async (payload) => { ... },
+});
+```
diff --git a/.agents/skills/trigger-tasks/SKILL.md b/.agents/skills/trigger-tasks/SKILL.md
new file mode 100644
index 0000000..7610c73
--- /dev/null
+++ b/.agents/skills/trigger-tasks/SKILL.md
@@ -0,0 +1,347 @@
+---
+name: trigger-tasks
+description: Build AI agents, workflows and durable background tasks with Trigger.dev. Use when creating tasks, triggering jobs, handling retries, scheduling cron jobs, or implementing queues and concurrency control.
+---
+
+# Trigger.dev Tasks
+
+Build durable background tasks that run reliably with automatic retries, queuing, and observability.
+
+## When to Use
+
+- Creating background jobs or async workflows
+- Building AI agents that need long-running execution
+- Processing webhooks, emails, or file uploads
+- Scheduling recurring tasks (cron)
+- Any work that shouldn't block your main application
+
+## Critical Rules
+
+1. **Always use `@trigger.dev/sdk`** — never use deprecated `client.defineJob`
+2. **Check `result.ok`** before accessing `result.output` from `triggerAndWait()`
+3. **Never use `Promise.all`** with `triggerAndWait()` or `wait.*` calls
+4. **Export tasks** from files in your `trigger/` directory
+
+## 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,
+  },
+  run: async (payload: { userId: string; data: any[] }) => {
+    console.log(`Processing ${payload.data.length} items`);
+    return { processed: payload.data.length };
+  },
+});
+```
+
+## Schema Task (Validated Input)
+
+```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 typed and validated
+    return { message: `Hello ${payload.name}` };
+  },
+});
+```
+
+## Triggering Tasks
+
+### From Backend Code
+
+```ts
+import { tasks } from "@trigger.dev/sdk";
+import type { processData } from "./trigger/tasks";
+
+// Single trigger (fire and forget)
+const handle = await tasks.trigger<typeof processData>("process-data", {
+  userId: "123",
+  data: [{ id: 1 }],
+});
+
+// Batch trigger (up to 1,000 items, 3MB per payload)
+const batchHandle = await tasks.batchTrigger<typeof processData>("process-data", [
+  { payload: { userId: "123", data: [] } },
+  { payload: { userId: "456", data: [] } },
+]);
+```
+
+### From Inside Tasks
+
+```ts
+export const parentTask = task({
+  id: "parent-task",
+  run: async (payload) => {
+    // Fire and forget
+    const handle = await childTask.trigger({ data: "value" });
+
+    // Wait for result - 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);
+    }
+
+    // Quick unwrap (throws on error)
+    const output = await childTask.triggerAndWait({ data: "value" }).unwrap();
+
+    // Batch with wait
+    const results = await childTask.batchTriggerAndWait([
+      { payload: { data: "item1" } },
+      { payload: { data: "item2" } },
+    ]);
+  },
+});
+```
+
+## Waits
+
+```ts
+import { task, wait } from "@trigger.dev/sdk";
+
+export const taskWithWaits = task({
+  id: "task-with-waits",
+  run: async (payload) => {
+    await wait.for({ seconds: 30 });
+    await wait.for({ minutes: 5 });
+    await wait.until({ date: new Date("2024-12-25") });
+
+    // Wait for external approval
+    await wait.forToken({
+      token: "user-approval-token",
+      timeoutInSeconds: 3600,
+    });
+  },
+});
+```
+
+> Waits > 5 seconds are checkpointed and don't count toward compute.
+
+## Concurrency & Queues
+
+```ts
+import { task, queue } from "@trigger.dev/sdk";
+
+// Shared queue
+const emailQueue = queue({
+  name: "email-processing",
+  concurrencyLimit: 5,
+});
+
+// Task-level concurrency
+export const oneAtATime = task({
+  id: "sequential-task",
+  queue: { concurrencyLimit: 1 },
+  run: async (payload) => {
+    // Only one instance runs at a time
+  },
+});
+
+// Use shared queue
+export const emailTask = task({
+  id: "send-email",
+  queue: emailQueue,
+  run: async (payload) => {},
+});
+
+// Per-tenant concurrency (at trigger time)
+await childTask.trigger(payload, {
+  queue: {
+    name: `user-${userId}`,
+    concurrencyLimit: 2,
+  },
+});
+```
+
+## Debouncing
+
+Consolidate rapid triggers into a single execution:
+
+```ts
+await myTask.trigger(
+  { userId: "123" },
+  {
+    debounce: {
+      key: "user-123-update",
+      delay: "5s",
+      mode: "trailing", // Use latest payload (default: "leading")
+    },
+  }
+);
+```
+
+## Idempotency
+
+```ts
+import { task, idempotencyKeys } from "@trigger.dev/sdk";
+
+export const paymentTask = task({
+  id: "process-payment",
+  run: async (payload: { orderId: string }) => {
+    const key = await idempotencyKeys.create(`payment-${payload.orderId}`);
+
+    await chargeCustomer.trigger(payload, {
+      idempotencyKey: key,
+      idempotencyKeyTTL: "24h",
+    });
+  },
+});
+```
+
+## 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,
+    minTimeoutInMs: 500,
+    maxTimeoutInMs: 30_000,
+  },
+  catchError: async ({ error, ctx }) => {
+    if (error.code === "FATAL_ERROR") {
+      throw new AbortTaskRunError("Cannot retry");
+    }
+    return { retryAt: new Date(Date.now() + 60000) };
+  },
+  run: async (payload) => {
+    // Retry specific operations
+    const result = await retry.onThrow(
+      async () => unstableApiCall(payload),
+      { maxAttempts: 3 }
+    );
+
+    // HTTP retries with conditions
+    const response = await retry.fetch("https://api.example.com", {
+      retry: {
+        maxAttempts: 5,
+        condition: (res, err) => res?.status === 429 || res?.status >= 500,
+      },
+    });
+  },
+});
+```
+
+## Scheduled Tasks (Cron)
+
+```ts
+import { schedules } from "@trigger.dev/sdk";
+
+// Declarative schedule
+export const dailyTask = schedules.task({
+  id: "daily-cleanup",
+  cron: "0 0 * * *", // Midnight UTC
+  run: async (payload) => {
+    // payload.timestamp - scheduled time
+    // payload.timezone - IANA timezone
+    // payload.scheduleId - schedule identifier
+  },
+});
+
+// With timezone
+export const tokyoTask = schedules.task({
+  id: "tokyo-morning",
+  cron: { pattern: "0 9 * * *", timezone: "Asia/Tokyo" },
+  run: async () => {},
+});
+
+// Dynamic/multi-tenant schedules
+await schedules.create({
+  task: "reminder-task",
+  cron: "0 8 * * *",
+  timezone: "America/New_York",
+  externalId: userId,
+  deduplicationKey: `${userId}-daily`,
+});
+```
+
+## Metadata & Progress
+
+```ts
+import { task, metadata } from "@trigger.dev/sdk";
+
+export const batchProcessor = task({
+  id: "batch-processor",
+  run: async (payload: { items: any[] }) => {
+    metadata.set("progress", 0).set("total", payload.items.length);
+
+    for (let i = 0; i < payload.items.length; i++) {
+      await processItem(payload.items[i]);
+      metadata.set("progress", ((i + 1) / payload.items.length) * 100);
+    }
+
+    metadata.set("status", "completed");
+  },
+});
+```
+
+## Tags
+
+```ts
+import { task, tags } from "@trigger.dev/sdk";
+
+export const processUser = task({
+  id: "process-user",
+  run: async (payload: { userId: string }) => {
+    await tags.add(`user_${payload.userId}`);
+  },
+});
+
+// Trigger with tags
+await processUser.trigger(
+  { userId: "123" },
+  { tags: ["priority", "user_123"] }
+);
+```
+
+## Machine Presets
+
+```ts
+export const heavyTask = task({
+  id: "heavy-computation",
+  machine: { preset: "large-2x" }, // 8 vCPU, 16 GB RAM
+  maxDuration: 1800, // 30 minutes
+  run: async (payload) => {},
+});
+```
+
+| Preset | vCPU | RAM |
+|--------|------|-----|
+| micro | 0.25 | 0.25 GB |
+| small-1x | 0.5 | 0.5 GB (default) |
+| small-2x | 1 | 1 GB |
+| medium-1x | 1 | 2 GB |
+| medium-2x | 2 | 4 GB |
+| large-1x | 4 | 8 GB |
+| large-2x | 8 | 16 GB |
+
+## Best Practices
+
+1. **Make tasks idempotent** — safe to retry without side effects
+2. **Use queues** to prevent overwhelming external services
+3. **Configure appropriate retries** with exponential backoff
+4. **Track progress with metadata** for long-running tasks
+5. **Use debouncing** for user activity and webhook bursts
+6. **Match machine size** to computational requirements
+
+See `references/` for detailed documentation on each feature.
diff --git a/.agents/skills/trigger-tasks/references/advanced-tasks.md b/.agents/skills/trigger-tasks/references/advanced-tasks.md
new file mode 100644
index 0000000..32a0033
--- /dev/null
+++ b/.agents/skills/trigger-tasks/references/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/.agents/skills/trigger-tasks/references/basic-tasks.md b/.agents/skills/trigger-tasks/references/basic-tasks.md
new file mode 100644
index 0000000..56bff34
--- /dev/null
+++ b/.agents/skills/trigger-tasks/references/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/.agents/skills/trigger-tasks/references/scheduled-tasks.md b/.agents/skills/trigger-tasks/references/scheduled-tasks.md
new file mode 100644
index 0000000..b314753
--- /dev/null
+++ b/.agents/skills/trigger-tasks/references/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/.gitignore b/.gitignore
index 10dcd9e..b51644e 100644
--- a/.gitignore
+++ b/.gitignore
@@ -47,3 +47,8 @@ yarn-error.log*
 next-env.d.ts
 
 /app/generated/prisma
+
+# trigger.dev
+.trigger
+
+.trigger
\ No newline at end of file
diff --git a/app/api/ai/design/route.ts b/app/api/ai/design/route.ts
new file mode 100644
index 0000000..0658435
--- /dev/null
+++ b/app/api/ai/design/route.ts
@@ -0,0 +1,67 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { tasks } from "@trigger.dev/sdk/v3";
+import { prisma } from "@/lib/prisma";
+import { getProjectAccess } from "@/lib/project-access";
+import type { designAgent } from "@/trigger/design-agent";
+
+export async function POST(request: Request) {
+  const { userId } = await auth();
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let prompt: unknown;
+  let roomId: unknown;
+  let projectId: unknown;
+
+  try {
+    const body = await request.json();
+    prompt = body.prompt;
+    roomId = body.roomId;
+    projectId = body.projectId;
+  } catch {
+    return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+  }
+
+  if (typeof prompt !== "string" || !prompt.trim()) {
+    return NextResponse.json({ error: "Prompt is required" }, { status: 400 });
+  }
+
+  if (typeof roomId !== "string" || !roomId) {
+    return NextResponse.json({ error: "Room ID is required" }, { status: 400 });
+  }
+
+  if (typeof projectId !== "string" || !projectId) {
+    return NextResponse.json({ error: "Project ID is required" }, { status: 400 });
+  }
+
+  const access = await getProjectAccess(projectId);
+  if (!access.hasAccess) {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  try {
+    const handle = await tasks.trigger<typeof designAgent>("design-agent", {
+      prompt: prompt.trim(),
+      roomId,
+      projectId,
+      userId,
+    });
+
+    await prisma.taskRun.create({
+      data: {
+        runId: handle.id,
+        projectId,
+        userId,
+      },
+    });
+
+    return NextResponse.json({ runId: handle.id }, { status: 201 });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to trigger design task" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/ai/design/token/route.ts b/app/api/ai/design/token/route.ts
new file mode 100644
index 0000000..32622f5
--- /dev/null
+++ b/app/api/ai/design/token/route.ts
@@ -0,0 +1,54 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { auth as triggerAuth } from "@trigger.dev/sdk/v3";
+import { prisma } from "@/lib/prisma";
+
+export async function POST(request: Request) {
+  const { userId } = await auth();
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let runId: unknown;
+
+  try {
+    const body = await request.json();
+    runId = body.runId;
+  } catch {
+    return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+  }
+
+  if (typeof runId !== "string" || !runId) {
+    return NextResponse.json({ error: "Run ID is required" }, { status: 400 });
+  }
+
+  try {
+    const taskRun = await prisma.taskRun.findUnique({
+      where: { runId },
+    });
+
+    if (!taskRun) {
+      return NextResponse.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    if (taskRun.userId !== userId) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    const publicToken = await triggerAuth.createPublicToken({
+      scopes: {
+        read: {
+          runs: [runId],
+        },
+      },
+      expirationTime: "15m",
+    });
+
+    return NextResponse.json({ token: publicToken });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to generate token" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/ai/spec/route.ts b/app/api/ai/spec/route.ts
new file mode 100644
index 0000000..de7f96d
--- /dev/null
+++ b/app/api/ai/spec/route.ts
@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { tasks } from "@trigger.dev/sdk/v3";
+import { prisma } from "@/lib/prisma";
+import { getProjectAccess } from "@/lib/project-access";
+import type { generateSpec } from "@/trigger/generate-spec";
+
+export async function POST(request: Request) {
+  const { userId } = await auth();
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let roomId: unknown;
+  let chatHistory: unknown;
+  let nodes: unknown;
+  let edges: unknown;
+
+  try {
+    const body = await request.json();
+    roomId = body.roomId;
+    chatHistory = body.chatHistory;
+    nodes = body.nodes;
+    edges = body.edges;
+  } catch {
+    return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+  }
+
+  if (typeof roomId !== "string" || !roomId) {
+    return NextResponse.json({ error: "Room ID is required" }, { status: 400 });
+  }
+
+  const access = await getProjectAccess(roomId);
+  if (!access.hasAccess || !access.project) {
+    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+  }
+
+  const projectId = access.project.id;
+
+  try {
+    const handle = await tasks.trigger<typeof generateSpec>("generate-spec", {
+      projectId,
+      roomId,
+      chatHistory: Array.isArray(chatHistory) ? chatHistory : [],
+      nodes: Array.isArray(nodes) ? nodes : [],
+      edges: Array.isArray(edges) ? edges : [],
+    });
+
+    await prisma.taskRun.create({
+      data: {
+        runId: handle.id,
+        projectId,
+        userId,
+      },
+    });
+
+    return NextResponse.json({ runId: handle.id }, { status: 201 });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to trigger spec generation task" },
+      { status: 500 },
+    );
+  }
+}
diff --git a/app/api/ai/spec/token/route.ts b/app/api/ai/spec/token/route.ts
new file mode 100644
index 0000000..ec14dd2
--- /dev/null
+++ b/app/api/ai/spec/token/route.ts
@@ -0,0 +1,54 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { auth as triggerAuth } from "@trigger.dev/sdk/v3";
+import { prisma } from "@/lib/prisma";
+
+export async function POST(request: Request) {
+  const { userId } = await auth();
+  if (!userId) {
+    return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+  }
+
+  let runId: unknown;
+
+  try {
+    const body = await request.json();
+    runId = body.runId;
+  } catch {
+    return NextResponse.json({ error: "Invalid request body" }, { status: 400 });
+  }
+
+  if (typeof runId !== "string" || !runId) {
+    return NextResponse.json({ error: "Run ID is required" }, { status: 400 });
+  }
+
+  try {
+    const taskRun = await prisma.taskRun.findUnique({
+      where: { runId },
+    });
+
+    if (!taskRun) {
+      return NextResponse.json({ error: "Run not found" }, { status: 404 });
+    }
+
+    if (taskRun.userId !== userId) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    const publicToken = await triggerAuth.createPublicToken({
+      scopes: {
+        read: {
+          runs: [runId],
+        },
+      },
+      expirationTime: "1h",
+    });
+
+    return NextResponse.json({ token: publicToken });
+  } catch {
+    return NextResponse.json(
+      { error: "Failed to generate token" },
+      { status: 500 },
+    );
+  }
+}
diff --git a/app/api/projects/[id]/specs/[specId]/content/route.ts b/app/api/projects/[id]/specs/[specId]/content/route.ts
new file mode 100644
index 0000000..65c2313
--- /dev/null
+++ b/app/api/projects/[id]/specs/[specId]/content/route.ts
@@ -0,0 +1,58 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { prisma } from "@/lib/prisma";
+import { getProjectAccess } from "@/lib/project-access";
+import { get } from "@vercel/blob";
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ id: string; specId: string }> }
+) {
+  try {
+    const session = await auth();
+    if (!session.userId) {
+      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const { id: projectId, specId } = await params;
+
+    const access = await getProjectAccess(projectId);
+    if (!access.hasAccess) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    const spec = await prisma.projectSpec.findUnique({
+      where: { id: specId },
+    });
+
+    if (!spec || spec.projectId !== projectId) {
+      return NextResponse.json({ error: "Spec not found" }, { status: 404 });
+    }
+
+    if (!spec.filePath) {
+      return NextResponse.json({ error: "Spec content not yet uploaded" }, { status: 503 });
+    }
+
+    const blobData = await get(spec.filePath, { access: "private" });
+    if (!blobData || blobData.statusCode === 304 || !blobData.stream) {
+      return NextResponse.json({ error: "Spec content not found" }, { status: 404 });
+    }
+
+    const reader = blobData.stream.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+
+    return NextResponse.json({ content: text });
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : "Failed to get spec content" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/projects/[id]/specs/[specId]/download/route.ts b/app/api/projects/[id]/specs/[specId]/download/route.ts
new file mode 100644
index 0000000..cc19014
--- /dev/null
+++ b/app/api/projects/[id]/specs/[specId]/download/route.ts
@@ -0,0 +1,64 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { prisma } from "@/lib/prisma";
+import { getProjectAccess } from "@/lib/project-access";
+import { get } from "@vercel/blob";
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ id: string; specId: string }> }
+) {
+  try {
+    const session = await auth();
+    if (!session.userId) {
+      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const { id: projectId, specId } = await params;
+
+    const access = await getProjectAccess(projectId);
+    if (!access.hasAccess) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    const spec = await prisma.projectSpec.findUnique({
+      where: { id: specId },
+    });
+
+    if (!spec || spec.projectId !== projectId) {
+      return NextResponse.json({ error: "Spec not found" }, { status: 404 });
+    }
+
+    if (!spec.filePath) {
+      return NextResponse.json({ error: "Spec content not yet uploaded" }, { status: 503 });
+    }
+
+    const blobData = await get(spec.filePath, { access: "private" });
+    if (!blobData || blobData.statusCode === 304 || !blobData.stream) {
+      return NextResponse.json({ error: "Spec content not found" }, { status: 404 });
+    }
+
+    const reader = blobData.stream.getReader();
+    const decoder = new TextDecoder();
+    let text = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      text += decoder.decode(value, { stream: true });
+    }
+    text += decoder.decode();
+
+    return new NextResponse(text, {
+      status: 200,
+      headers: {
+        "Content-Type": "text/markdown",
+        "Content-Disposition": `attachment; filename="${specId}.md"`,
+      },
+    });
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : "Failed to download spec" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/app/api/projects/[id]/specs/route.ts b/app/api/projects/[id]/specs/route.ts
new file mode 100644
index 0000000..83b5193
--- /dev/null
+++ b/app/api/projects/[id]/specs/route.ts
@@ -0,0 +1,41 @@
+import { NextResponse } from "next/server";
+import { auth } from "@clerk/nextjs/server";
+import { prisma } from "@/lib/prisma";
+import { getProjectAccess } from "@/lib/project-access";
+
+export async function GET(
+  _request: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const session = await auth();
+    if (!session.userId) {
+      return NextResponse.json({ error: "Unauthorized" }, { status: 401 });
+    }
+
+    const projectId = (await params).id;
+
+    const access = await getProjectAccess(projectId);
+    if (!access.hasAccess) {
+      return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+    }
+
+    const specs = await prisma.projectSpec.findMany({
+      where: { projectId },
+      select: {
+        id: true,
+        projectId: true,
+        filePath: true,
+        createdAt: true,
+      },
+      orderBy: { createdAt: "desc" },
+    });
+
+    return NextResponse.json(specs);
+  } catch (e) {
+    return NextResponse.json(
+      { error: e instanceof Error ? e.message : "Failed to list specs" },
+      { status: 500 }
+    );
+  }
+}
diff --git a/components/editor/ai-sidebar.tsx b/components/editor/ai-sidebar.tsx
index baf7cf5..6534a67 100644
--- a/components/editor/ai-sidebar.tsx
+++ b/components/editor/ai-sidebar.tsx
@@ -1,20 +1,40 @@
 "use client"
 
-import { useRef, useState } from "react"
-import { X, Bot, Sparkles, FileText, Download, Send } from "lucide-react"
+import { useRef, useState, useEffect, useCallback, useContext } from "react"
+import { X, Bot, Sparkles, FileText, Download, Send, Loader2 } from "lucide-react"
 import { Button } from "@/components/ui/button"
 import { Textarea } from "@/components/ui/textarea"
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
 import { ScrollArea } from "@/components/ui/scroll-area"
+import {
+  Dialog,
+  DialogContent,
+  DialogHeader,
+  DialogTitle,
+} from "@/components/ui/dialog"
+import { useFeeds, useCreateFeed, useFeedMessages, useCreateFeedMessage } from "@liveblocks/react"
+import { useUser } from "@clerk/nextjs"
+import { useRealtimeRun } from "@trigger.dev/react-hooks"
+import ReactMarkdown from "react-markdown"
+import type { AiStatusPayload } from "@/types/canvas"
+import { AiChatMessageSchema } from "@/types/task"
+import type { designAgent } from "@/trigger/design-agent"
+import type { generateSpec } from "@/trigger/generate-spec"
+import type { RealtimeRun } from "@trigger.dev/core/v3"
+import { CanvasStateContext } from "./canvas"
+
+interface ProjectSpecItem {
+  id: string
+  projectId: string
+  filePath: string | null
+  createdAt: string
+}
 
 interface AiSidebarProps {
   isOpen: boolean
   onClose: () => void
-}
-
-interface ChatMessage {
-  role: "user" | "assistant"
-  content: string
+  aiStatus?: AiStatusPayload | null
+  projectId: string
 }
 
 const STARTER_CHIPS = [
@@ -23,19 +43,214 @@ const STARTER_CHIPS = [
   "Build a CI/CD pipeline",
 ]
 
-export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
-  const [messages, setMessages] = useState<ChatMessage[]>([])
+export function AiSidebar({ isOpen, onClose, aiStatus, projectId }: AiSidebarProps) {
   const [input, setInput] = useState("")
+  const [sendError, setSendError] = useState<string | null>(null)
+  const [isSubmitting, setIsSubmitting] = useState(false)
+  const [runId, setRunId] = useState<string | null>(null)
+  const [publicToken, setPublicToken] = useState<string | null>(null)
   const textareaRef = useRef<HTMLTextAreaElement>(null)
+  const { user } = useUser()
+  const { feeds } = useFeeds()
+  const createFeed = useCreateFeed()
+  const { messages: feedMessages } = useFeedMessages("ai-chat")
+  const createFeedMessage = useCreateFeedMessage()
+
+  const [specs, setSpecs] = useState<ProjectSpecItem[]>([])
+  const [specsLoading, setSpecsLoading] = useState(false)
+  const [selectedSpec, setSelectedSpec] = useState<ProjectSpecItem | null>(null)
+  const [previewOpen, setPreviewOpen] = useState(false)
+  const [previewContent, setPreviewContent] = useState<string | null>(null)
+  const [previewLoading, setPreviewLoading] = useState(false)
+  const [specRunId, setSpecRunId] = useState<string | null>(null)
+  const [specRunToken, setSpecRunToken] = useState<string | null>(null)
+
+  const { getCanvasState } = useContext(CanvasStateContext)
+
+  const fetchSpecs = useCallback(async () => {
+    setSpecsLoading(true)
+    try {
+      const res = await fetch(`/api/projects/${projectId}/specs`)
+      if (res.ok) {
+        const data = await res.json()
+        setSpecs(data)
+      }
+    } catch {
+      // silent
+    }
+    setSpecsLoading(false)
+  }, [projectId])
+
+  useEffect(() => {
+    fetchSpecs()
+  }, [fetchSpecs])
+
+  const openPreview = useCallback(async (spec: ProjectSpecItem) => {
+    setSelectedSpec(spec)
+    setPreviewOpen(true)
+    setPreviewLoading(true)
+    setPreviewContent(null)
+    try {
+      const res = await fetch(`/api/projects/${projectId}/specs/${spec.id}/content`)
+      if (res.ok) {
+        const data = await res.json()
+        setPreviewContent(data.content)
+      } else {
+        setPreviewContent("*Failed to load spec content*")
+      }
+    } catch {
+      setPreviewContent("*Failed to load spec content*")
+    }
+    setPreviewLoading(false)
+  }, [projectId])
+
+  const handleDownload = useCallback(async (spec: ProjectSpecItem) => {
+    const a = document.createElement("a")
+    a.href = `/api/projects/${projectId}/specs/${spec.id}/download`
+    a.download = `${spec.id}.md`
+    document.body.appendChild(a)
+    a.click()
+    document.body.removeChild(a)
+  }, [projectId])
+
+  const senderName = user?.fullName || user?.username || user?.primaryEmailAddress?.emailAddress || "Anonymous"
+  const isRunActive = isSubmitting || !!runId
+
+  const { run } = useRealtimeRun<typeof designAgent>(runId ?? undefined, {
+    accessToken: publicToken ?? undefined,
+    enabled: !!runId && !!publicToken,
+    onComplete: useCallback(
+      async (runResult: RealtimeRun<typeof designAgent>) => {
+        const output = runResult.output as
+          | { status?: string; nodesGenerated?: number; edgesGenerated?: number }
+          | undefined
+        const content =
+          output?.status === "complete"
+            ? `Design generated with ${output.nodesGenerated} nodes and ${output.edgesGenerated} edges`
+            : "Could not generate a design from that prompt"
+        try {
+          await createFeedMessage("ai-chat", {
+            sender: "AI Architect",
+            role: "assistant",
+            content,
+            timestamp: Date.now(),
+          })
+        } catch {
+          // silent
+        }
+        setRunId(null)
+        setPublicToken(null)
+      },
+      [createFeedMessage],
+    ),
+  })
+
+  useRealtimeRun<typeof generateSpec>(specRunId ?? undefined, {
+    accessToken: specRunToken ?? undefined,
+    enabled: !!specRunId && !!specRunToken,
+    onComplete: useCallback(async () => {
+      setSpecRunId(null)
+      setSpecRunToken(null)
+      await fetchSpecs()
+    }, [fetchSpecs]),
+  })
+
+  useEffect(() => {
+    if (!feeds) return
+    const exists = feeds.some((f) => f.feedId === "ai-chat")
+    if (!exists) {
+      createFeed("ai-chat").catch(() => {})
+    }
+  }, [feeds, createFeed])
+
+  const validatedMessages = (feedMessages ?? [])
+    .map((msg) => {
+      const parsed = AiChatMessageSchema.safeParse(msg.data)
+      if (parsed.success) {
+        return { ...parsed.data, id: msg.id }
+      }
+      return null
+    })
+    .filter((m): m is NonNullable<typeof m> => m !== null)
+
+  const submitPrompt = useCallback(
+    async (text: string) => {
+      if (isRunActive) return
+      setSendError(null)
+      setIsSubmitting(true)
+      try {
+        await createFeedMessage("ai-chat", {
+          sender: senderName,
+          role: "user",
+          content: text,
+          timestamp: Date.now(),
+        })
+      } catch {
+        setSendError("Failed to send message")
+        setIsSubmitting(false)
+        return
+      }
+
+      try {
+        const res = await fetch("/api/ai/design", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ prompt: text, roomId: projectId, projectId }),
+        })
+        if (!res.ok) {
+          const err = await res.json().catch(() => ({}))
+          await createFeedMessage("ai-chat", {
+            sender: "System",
+            role: "assistant",
+            content: err.error || "Failed to start design task",
+            timestamp: Date.now(),
+          }).catch(() => {})
+          setIsSubmitting(false)
+          return
+        }
+        const { runId: newRunId } = await res.json()
+
+        const tokenRes = await fetch("/api/ai/design/token", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ runId: newRunId }),
+        })
+        if (!tokenRes.ok) {
+          await createFeedMessage("ai-chat", {
+            sender: "System",
+            role: "assistant",
+            content: "Failed to get access token",
+            timestamp: Date.now(),
+          }).catch(() => {})
+          setIsSubmitting(false)
+          return
+        }
+        const { token } = await tokenRes.json()
+
+        setRunId(newRunId)
+        setPublicToken(token)
+      } catch {
+        setSendError("Network error")
+        await createFeedMessage("ai-chat", {
+          sender: "System",
+          role: "assistant",
+          content: "Network error: failed to send message",
+          timestamp: Date.now(),
+        }).catch(() => {})
+      }
+      setIsSubmitting(false)
+    },
+    [senderName, projectId, createFeedMessage, isRunActive],
+  )
 
-  const handleSend = () => {
+  const handleSend = async () => {
     const text = input.trim()
     if (!text) return
-    setMessages((prev) => [...prev, { role: "user", content: text }])
     setInput("")
     if (textareaRef.current) {
       textareaRef.current.style.height = "auto"
     }
+    await submitPrompt(text)
   }
 
   const handleInputChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
@@ -52,13 +267,45 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
     }
   }
 
-  const handleStarterClick = (chip: string) => {
-    setMessages((prev) => [...prev, { role: "user", content: chip }])
-    setInput("")
+  const handleStarterClick = async (chip: string) => {
+    if (isRunActive) return
+    await submitPrompt(chip)
   }
 
+  const handleGenerateSpec = useCallback(async () => {
+    if (specRunId) return
+    const { nodes, edges } = getCanvasState()
+    const chatHistory = validatedMessages.map(m => ({ role: m.role, content: m.content }))
+    try {
+      const res = await fetch("/api/ai/spec", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ roomId: projectId, chatHistory, nodes, edges }),
+      })
+      if (!res.ok) {
+        return
+      }
+      const { runId: newRunId } = await res.json()
+      const tokenRes = await fetch("/api/ai/spec/token", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ runId: newRunId }),
+      })
+      if (!tokenRes.ok) {
+        return
+      }
+      const { token } = await tokenRes.json()
+      setSpecRunId(newRunId)
+      setSpecRunToken(token)
+    } catch {
+      // silent
+    }
+  }, [projectId, getCanvasState, validatedMessages, specRunId])
+
   return (
     <aside
+      aria-hidden={!isOpen}
+      inert={!isOpen ? true : undefined}
       className={`absolute right-0 top-0 bottom-0 w-72 border-l border-border-default bg-base/95 z-30 flex flex-col shadow-2xl transition-transform duration-200 ${
         isOpen ? "translate-x-0" : "translate-x-full"
       } ${isOpen ? "" : "pointer-events-none"}`}
@@ -75,9 +322,17 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
             </p>
           </div>
         </div>
-        <Button variant="ghost" size="icon" onClick={onClose} className="h-7 w-7 shrink-0">
-          <X className="h-4 w-4" />
-        </Button>
+        <div className="flex items-center gap-2 shrink-0">
+          {aiStatus?.text && (
+            <div className="flex items-center gap-1.5 rounded-full bg-ai/10 px-2.5 py-1 text-xs text-ai-text">
+              <Loader2 className="h-3 w-3 animate-spin" />
+              <span className="truncate max-w-[100px]">{aiStatus.text}</span>
+            </div>
+          )}
+          <Button variant="ghost" size="icon" onClick={onClose} className="h-7 w-7 shrink-0" aria-label="Close">
+            <X className="h-4 w-4" />
+          </Button>
+        </div>
       </div>
 
       <Tabs defaultValue="architect" className="flex flex-col flex-1 overflow-hidden">
@@ -99,7 +354,7 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
         </div>
 
         <TabsContent value="architect" className="flex flex-col flex-1 overflow-hidden p-0 m-0">
-          {messages.length === 0 ? (
+          {validatedMessages.length === 0 ? (
             <div className="flex-1 flex flex-col items-center justify-center px-6 text-center gap-3">
               <Bot className="h-10 w-10 text-ai-text" />
               <p className="text-sm text-copy-muted leading-relaxed">
@@ -120,19 +375,26 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
           ) : (
             <ScrollArea className="flex-1 px-4">
               <div className="py-3 space-y-3">
-                {messages.map((msg, i) => (
-                  <div
-                    key={i}
-                    className={`flex ${msg.role === "user" ? "justify-end" : "justify-start"}`}
-                  >
+                {validatedMessages.map((msg) => (
                     <div
-                      className={`max-w-[85%] rounded-lg px-3 py-2 text-sm leading-relaxed ${
-                        msg.role === "user"
-                          ? "bg-brand-dim border-brand/50 border-2 text-copy-primary"
-                          : "bg-elevated border border-border-default text-ai-text"
-                      }`}
+                      key={msg.id}
+                      className={`flex flex-col ${msg.role === "user" ? "items-end" : "items-start"}`}
                     >
+                      <div
+                       className={`max-w-[85%] rounded-lg px-3 py-2 text-sm leading-relaxed ${
+                         msg.role === "user"
+                           ? "text-copy-primary"
+                           : "bg-elevated border border-border-default text-ai-text"
+                       }`}
+                       style={msg.role === "user" ? { backgroundColor: "#62C073", border: "2px solid #62C073" } : undefined}
+                     >
+                      <span className="block text-[10px] opacity-60 mb-1">
+                        {msg.sender}
+                      </span>
                       {msg.content}
+                      <span className="block text-[10px] opacity-40 mt-1">
+                        {new Date(msg.timestamp).toLocaleTimeString(undefined, { hour: "2-digit", minute: "2-digit" })}
+                      </span>
                     </div>
                   </div>
                 ))}
@@ -141,22 +403,39 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
           )}
 
           <div className="p-4 border-t border-border-default">
+            {sendError && (
+              <p className="text-xs text-state-error mb-2">{sendError}</p>
+            )}
+            {isRunActive && aiStatus?.text && (
+              <div className="mb-2 flex items-center gap-2 rounded-md bg-surface px-3 py-1.5 text-xs text-ai-text border-l-2 border-[#62C073]">
+                <span className="h-1.5 w-1.5 rounded-full bg-[#62C073] animate-pulse shrink-0" />
+                <span className="truncate">{aiStatus.text}</span>
+              </div>
+            )}
             <div className="flex gap-2 items-end">
               <Textarea
                 ref={textareaRef}
                 value={input}
                 onChange={handleInputChange}
                 onKeyDown={handleKeyDown}
-                placeholder="Ask AI..."
+                placeholder={isRunActive ? "AI is working…" : "Ask AI..."}
                 className="min-h-[72px] max-h-[160px] resize-none text-sm"
                 rows={1}
+                disabled={isRunActive}
               />
               <Button
                 onClick={handleSend}
                 size="icon"
-                className="h-11 w-11 shrink-0 bg-accent text-white hover:bg-accent/80"
+                className="h-11 w-11 shrink-0 text-white hover:opacity-80 disabled:opacity-30 disabled:cursor-not-allowed"
+                style={{ backgroundColor: "#62C073" }}
+                aria-label="Send message"
+                disabled={isRunActive}
               >
-                <Send className="h-4 w-4" />
+                {isRunActive ? (
+                  <Loader2 className="h-4 w-4 animate-spin" />
+                ) : (
+                  <Send className="h-4 w-4" />
+                )}
               </Button>
             </div>
           </div>
@@ -164,37 +443,110 @@ export function AiSidebar({ isOpen, onClose }: AiSidebarProps) {
 
         <TabsContent value="specs" className="flex flex-col flex-1 overflow-hidden p-0 m-0">
           <div className="flex flex-col gap-3 p-4">
-            <Button className="w-full bg-accent text-white hover:bg-accent/80">
-              <Sparkles className="h-4 w-4" />
-              Generate Spec
+            <Button
+              onClick={handleGenerateSpec}
+              disabled={!!specRunId}
+              className="w-full bg-accent text-white hover:bg-accent/80 disabled:opacity-50 disabled:cursor-not-allowed"
+            >
+              {specRunId ? (
+                <Loader2 className="h-4 w-4 animate-spin" />
+              ) : (
+                <Sparkles className="h-4 w-4" />
+              )}
+              {specRunId ? "Generating…" : "Generate Spec"}
             </Button>
 
-            <div className="rounded-lg border border-border-default bg-elevated p-4">
-              <div className="flex items-start gap-3">
-                <FileText className="h-5 w-5 text-ai-text mt-0.5 shrink-0" />
-                <div className="min-w-0">
-                  <h4 className="text-sm font-medium text-copy-primary">
-                    API Gateway Spec
-                  </h4>
-                  <p className="text-xs text-copy-muted mt-1 line-clamp-2">
-                    Defines the REST API endpoints for the e-commerce platform
-                    including product catalog, user auth, and order management
-                    with rate limiting.
-                  </p>
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    disabled
-                    className="mt-2 h-8 px-2 text-xs text-copy-muted"
-                  >
-                    <Download className="h-3.5 w-3.5 mr-1" />
-                    Download
-                  </Button>
-                </div>
+            {specsLoading ? (
+              <div className="flex items-center justify-center py-8">
+                <Loader2 className="h-5 w-5 animate-spin text-copy-muted" />
               </div>
-            </div>
+            ) : specs.length === 0 ? (
+              <p className="text-xs text-copy-muted text-center py-8">
+                No specs yet. Generate one above.
+              </p>
+            ) : (
+              <ScrollArea className="flex-1 -mx-4 px-4">
+                <div className="space-y-2 pb-2">
+                  {specs.map((spec) => (
+                    <button
+                      key={spec.id}
+                      onClick={() => openPreview(spec)}
+                      className="w-full text-left rounded-lg border border-border-default bg-elevated p-3 hover:bg-subtle transition-colors cursor-pointer"
+                    >
+                      <div className="flex items-start gap-3">
+                        <FileText className="h-5 w-5 text-ai-text mt-0.5 shrink-0" />
+                        <div className="min-w-0 flex-1">
+                          <h4 className="text-sm font-medium text-copy-primary truncate">
+                            {spec.id.slice(0, 8)}…
+                          </h4>
+                          <p className="text-xs text-copy-muted mt-0.5">
+                            {new Date(spec.createdAt).toLocaleDateString(undefined, {
+                              month: "short",
+                              day: "numeric",
+                              year: "numeric",
+                              hour: "2-digit",
+                              minute: "2-digit",
+                            })}
+                          </p>
+                        </div>
+                        <Button
+                          variant="ghost"
+                          size="sm"
+                          onClick={(e) => {
+                            e.stopPropagation()
+                            handleDownload(spec)
+                          }}
+                          className="h-8 w-8 p-0 shrink-0 text-copy-muted hover:text-copy-primary"
+                          aria-label="Download spec"
+                        >
+                          <Download className="h-3.5 w-3.5" />
+                        </Button>
+                      </div>
+                    </button>
+                  ))}
+                </div>
+              </ScrollArea>
+            )}
           </div>
         </TabsContent>
+
+        <Dialog open={previewOpen} onOpenChange={setPreviewOpen}>
+          <DialogContent className="max-w-2xl max-h-[80vh] flex flex-col">
+            <DialogHeader>
+              <DialogTitle className="text-sm font-medium text-copy-primary">
+                {selectedSpec ? `${selectedSpec.id.slice(0, 8)}…` : "Spec Preview"}
+              </DialogTitle>
+            </DialogHeader>
+            <div className="flex-1 overflow-hidden flex flex-col min-h-0">
+              {previewLoading ? (
+                <div className="flex items-center justify-center py-12">
+                  <Loader2 className="h-6 w-6 animate-spin text-copy-muted" />
+                </div>
+              ) : previewContent ? (
+                <ScrollArea className="flex-1">
+                  <div className="prose prose-sm prose-invert max-w-none px-1 pb-4">
+                    <ReactMarkdown>{previewContent}</ReactMarkdown>
+                  </div>
+                </ScrollArea>
+              ) : (
+                <p className="text-sm text-copy-muted text-center py-8">
+                  No content available.
+                </p>
+              )}
+            </div>
+            <div className="flex justify-end pt-2 border-t border-border-default">
+              <Button
+                variant="outline"
+                size="sm"
+                onClick={() => selectedSpec && handleDownload(selectedSpec)}
+                className="text-xs"
+              >
+                <Download className="h-3.5 w-3.5 mr-1" />
+                Download
+              </Button>
+            </div>
+          </DialogContent>
+        </Dialog>
       </Tabs>
     </aside>
   )
diff --git a/components/editor/canvas.tsx b/components/editor/canvas.tsx
index 8be488e..680f90f 100644
--- a/components/editor/canvas.tsx
+++ b/components/editor/canvas.tsx
@@ -1,8 +1,7 @@
 "use client"
 
-import { Component, type ReactNode, useCallback, useRef, useState, useEffect, createContext, useContext } from "react"
-import { LiveObject, LiveMap } from "@liveblocks/core"
-import { LiveblocksProvider, RoomProvider, ClientSideSuspense, useHistory, useUpdateMyPresence, useOthers } from "@liveblocks/react"
+import { Component, type ReactNode, useCallback, useRef, useState, useEffect, useMemo, createContext, useContext } from "react"
+import { LiveblocksProvider, RoomProvider, ClientSideSuspense, useHistory, useUpdateMyPresence, useOthers, useFeeds, useCreateFeed, useFeedMessages } from "@liveblocks/react"
 import { UserButton } from "@clerk/nextjs"
 import { useLiveblocksFlow } from "@liveblocks/react-flow"
 import { LiveCursors } from "./live-cursors"
@@ -12,18 +11,57 @@ import "@xyflow/react/dist/style.css"
 import { ShapePanel, getShapePayload } from "./shape-panel"
 import { CollaboratorAvatars } from "./collaborator-avatars"
 import type { CanvasNodeData, CanvasNode, CanvasEdge } from "@/types/canvas"
+import type { AiStatusPayload } from "@/types/canvas"
+import { AiStatusSchema } from "@/types/task"
 import { NODE_COLORS } from "@/types/canvas"
 import type { CanvasTemplate } from "./starter-templates"
+import { AiSidebar } from "./ai-sidebar"
 import { ZoomIn, ZoomOut, Maximize, Undo, Redo, Cloud, CloudOff, LoaderIcon } from "lucide-react"
 import { useKeyboardShortcuts } from "@/hooks/use-keyboard-shortcuts"
 import { useCanvasAutosave } from "@/hooks/use-canvas-autosave"
 
+function AiStatusFeed({ onStatusChange }: { onStatusChange?: (status: AiStatusPayload | null) => void }) {
+  const { feeds } = useFeeds()
+  const createFeed = useCreateFeed()
+  const { messages } = useFeedMessages("ai-status-feed")
+
+  useEffect(() => {
+    if (!feeds) return
+    const exists = feeds.some((f) => f.feedId === "ai-status-feed")
+    if (!exists) {
+      createFeed("ai-status-feed").catch(() => {})
+    }
+  }, [feeds, createFeed])
+
+  useEffect(() => {
+    if (!messages || messages.length === 0) {
+      onStatusChange?.(null)
+      return
+    }
+    const latest = messages[messages.length - 1]
+    const parsed = AiStatusSchema.safeParse(latest.data)
+    if (parsed.success) {
+      onStatusChange?.(parsed.data.text ? parsed.data : null)
+    } else {
+      onStatusChange?.(null)
+    }
+  }, [messages, onStatusChange])
+
+  return null
+}
+
 const NodeEditContext = createContext<{
   updateNodeLabel: (id: string, label: string) => void
   updateNodeColor: (id: string, color: string, textColor: string) => void
   updateEdgeLabel: (id: string, label: string) => void
 }>({ updateNodeLabel: () => {}, updateNodeColor: () => {}, updateEdgeLabel: () => {} })
 
+export const CanvasStateContext = createContext<{
+  getCanvasState: () => { nodes: readonly Node[]; edges: readonly Edge[] }
+}>({
+  getCanvasState: () => ({ nodes: [], edges: [] }),
+})
+
 class ErrorBoundary extends Component<
   { fallback: ReactNode; children: ReactNode },
   { hasError: boolean }
@@ -390,9 +428,13 @@ function ColorToolbar() {
   )
 }
 
-function FlowCanvas({ projectId, onRegister }: { projectId: string; onRegister?: (fn: ((template: CanvasTemplate) => void) | null) => void }) {
+function FlowCanvas({ projectId, onRegister, onRegisterGetCanvasState }: { projectId: string; onRegister?: (fn: ((template: CanvasTemplate) => void) | null) => void; onRegisterGetCanvasState?: (fn: (() => { nodes: readonly Node[]; edges: readonly Edge[] }) | null) => void }) {
   const { nodes, edges, onNodesChange, onEdgesChange, onConnect, onDelete } =
-    useLiveblocksFlow<CanvasNode, CanvasEdge>({ suspense: true })
+    useLiveblocksFlow<CanvasNode, CanvasEdge>({
+      suspense: true,
+      nodes: { sync: { canvasNode: { data: true } } },
+      edges: { sync: { canvasEdge: { data: true } } },
+    })
   const reactFlow = useReactFlow<CanvasNode, CanvasEdge>()
   const counterRef = useRef(0)
   const { undo, redo, canUndo, canRedo } = useHistory()
@@ -524,11 +566,21 @@ function FlowCanvas({ projectId, onRegister }: { projectId: string; onRegister?:
     [reactFlow, onNodesChange, onEdgesChange],
   )
 
+  const nodesRef = useRef(nodes)
+  const edgesRef = useRef(edges)
+  nodesRef.current = nodes
+  edgesRef.current = edges
+
   useEffect(() => {
     onRegister?.(importTemplate)
     return () => onRegister?.(null)
   }, [importTemplate, onRegister])
 
+  useEffect(() => {
+    onRegisterGetCanvasState?.(() => ({ nodes: nodesRef.current, edges: edgesRef.current }))
+    return () => onRegisterGetCanvasState?.(null)
+  }, [onRegisterGetCanvasState])
+
   const onDragOver: React.DragEventHandler<HTMLDivElement> = useCallback((e) => {
     e.preventDefault()
     e.dataTransfer.dropEffect = "copy"
@@ -685,11 +737,11 @@ function FlowCanvas({ projectId, onRegister }: { projectId: string; onRegister?:
   )
 }
 
-function CanvasInner({ projectId, onRegister }: { projectId: string; onRegister?: (fn: ((template: CanvasTemplate) => void) | null) => void }) {
+function CanvasInner({ projectId, onRegister, onRegisterGetCanvasState }: { projectId: string; onRegister?: (fn: ((template: CanvasTemplate) => void) | null) => void; onRegisterGetCanvasState?: (fn: (() => { nodes: readonly Node[]; edges: readonly Edge[] }) | null) => void }) {
   return (
     <div className="flex-1">
       <ReactFlowProvider>
-        <FlowCanvas projectId={projectId} onRegister={onRegister} />
+        <FlowCanvas projectId={projectId} onRegister={onRegister} onRegisterGetCanvasState={onRegisterGetCanvasState} />
       </ReactFlowProvider>
     </div>
   )
@@ -715,24 +767,38 @@ interface CanvasProps {
   roomId: string
   projectId: string
   onRegisterImportTemplate?: (fn: ((template: CanvasTemplate) => void) | null) => void
+  onAiStatusChange?: (status: AiStatusPayload | null) => void
+  isAiSidebarOpen?: boolean
+  onAiSidebarClose?: () => void
+  aiStatus?: AiStatusPayload | null
 }
 
-export function Canvas({ roomId, projectId, onRegisterImportTemplate }: CanvasProps) {
+export function Canvas({ roomId, projectId, onRegisterImportTemplate, onAiStatusChange, isAiSidebarOpen, onAiSidebarClose, aiStatus }: CanvasProps) {
+  const getCanvasStateRef = useRef<() => { nodes: readonly Node[]; edges: readonly Edge[] }>(() => ({ nodes: [], edges: [] }))
+  const handleRegisterGetCanvasState = useCallback((fn: (() => { nodes: readonly Node[]; edges: readonly Edge[] }) | null) => {
+    getCanvasStateRef.current = fn ?? (() => ({ nodes: [], edges: [] }))
+  }, [])
+  const canvasStateValue = useMemo(() => ({
+    getCanvasState: () => getCanvasStateRef.current(),
+  }), [])
+
   return (
+    <CanvasStateContext.Provider value={canvasStateValue}>
     <ErrorBoundary fallback={<ErrorFallback />}>
       <LiveblocksProvider authEndpoint="/api/liveblocks-auth">
         <RoomProvider
           id={roomId}
           initialPresence={{ cursor: null, isThinking: false }}
-          initialStorage={{
-            flow: new LiveObject({ nodes: new LiveMap(), edges: new LiveMap() }),
-          }}
+          initialStorage={undefined as unknown as never}
         >
+          <AiStatusFeed onStatusChange={onAiStatusChange} />
           <ClientSideSuspense fallback={<Loading />}>
-            <CanvasInner projectId={projectId} onRegister={onRegisterImportTemplate} />
+            <CanvasInner projectId={projectId} onRegister={onRegisterImportTemplate} onRegisterGetCanvasState={handleRegisterGetCanvasState} />
           </ClientSideSuspense>
+          <AiSidebar isOpen={!!isAiSidebarOpen} onClose={() => onAiSidebarClose?.()} aiStatus={aiStatus} projectId={projectId} />
         </RoomProvider>
       </LiveblocksProvider>
     </ErrorBoundary>
+    </CanvasStateContext.Provider>
   )
 }
diff --git a/components/editor/live-cursors.tsx b/components/editor/live-cursors.tsx
index 6e742af..ee0a51a 100644
--- a/components/editor/live-cursors.tsx
+++ b/components/editor/live-cursors.tsx
@@ -12,6 +12,7 @@ function CursorPointer({
     cursor: other.presence.cursor,
     name: other.info?.name || "Anonymous",
     color: other.info?.color || "#666",
+    thinking: other.presence.isThinking,
   }))
   const reactFlow = useReactFlow()
 
@@ -65,8 +66,17 @@ function CursorPointer({
           fontWeight: "600",
           whiteSpace: "nowrap",
           boxShadow: "0 2px 4px rgba(0, 0, 0, 0.3)",
+          display: "flex",
+          alignItems: "center",
+          gap: "4px",
         }}
       >
+        {other.thinking && (
+          <svg className="animate-spin" width="10" height="10" viewBox="0 0 24 24" fill="none">
+            <circle cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4" opacity="0.25" />
+            <path d="M12 2a10 10 0 0 1 10 10" stroke="currentColor" strokeWidth="4" strokeLinecap="round" />
+          </svg>
+        )}
         {name}
       </div>
     </div>
diff --git a/components/editor/workspace-shell.tsx b/components/editor/workspace-shell.tsx
index f5494d8..8e98bef 100644
--- a/components/editor/workspace-shell.tsx
+++ b/components/editor/workspace-shell.tsx
@@ -4,9 +4,9 @@ import { useState, useCallback } from "react"
 import { WorkspaceNavbar } from "./workspace-navbar"
 import { ShareDialog } from "./share-dialog"
 import { Canvas } from "./canvas"
-import { AiSidebar } from "./ai-sidebar"
 import { StarterTemplateModal } from "./starter-template-modal"
 import type { CanvasTemplate } from "./starter-templates"
+import type { AiStatusPayload } from "@/types/canvas"
 
 interface WorkspaceShellProps {
   projectName: string
@@ -23,6 +23,7 @@ export function WorkspaceShell({
   const [shareOpen, setShareOpen] = useState(false)
   const [templateModalOpen, setTemplateModalOpen] = useState(false)
   const [importTemplate, setImportTemplate] = useState<((t: CanvasTemplate) => void) | null>(null)
+  const [aiStatus, setAiStatus] = useState<AiStatusPayload | null>(null)
 
   const handleImport = useCallback(
     (template: CanvasTemplate) => {
@@ -62,9 +63,7 @@ export function WorkspaceShell({
       />
 
       <div className="relative flex flex-1 overflow-hidden">
-        <Canvas roomId={projectId} projectId={projectId} onRegisterImportTemplate={handleRegisterImport} />
-
-        <AiSidebar isOpen={isAiSidebarOpen} onClose={() => setIsAiSidebarOpen(false)} />
+        <Canvas roomId={projectId} projectId={projectId} onRegisterImportTemplate={handleRegisterImport} onAiStatusChange={setAiStatus} isAiSidebarOpen={isAiSidebarOpen} onAiSidebarClose={() => setIsAiSidebarOpen(false)} aiStatus={aiStatus} />
       </div>
     </div>
   )
diff --git a/context/feature-specs/22-design-agent-api.md b/context/feature-specs/22-design-agent-api.md
index ae5c9a9..972df7b 100644
--- a/context/feature-specs/22-design-agent-api.md
+++ b/context/feature-specs/22-design-agent-api.md
@@ -1,4 +1,4 @@
-Set up the backedn flow for design generation using Trigger.dev. 
+Set up the backend flow for design generation using Trigger.dev. 
 This unit handles triggering background jobs, tracking runs, and issuing tokens. No AI logic yet.
 
 ## Implementation
@@ -14,7 +14,7 @@ This unit handles triggering background jobs, tracking runs, and issuing tokens.
 
 2. Add task run tracking.
 
-    Create as `TaskRun` model in Prisma to track Trigger.dev runs and verify ownerhship.
+    Create as `TaskRun` model in Prisma to track Trigger.dev runs and verify ownership.
 
     It should include:
     - `runId` (unique)
@@ -31,7 +31,7 @@ This unit handles triggering background jobs, tracking runs, and issuing tokens.
     Create: `POST /api/ai/design/token`
     This route should:
     - accept a run ID 
-    - verify owenership using the TaskRun record 
+    - verify ownership using the TaskRun record 
     - generate a Trigger.dev public token scoped to that run
     - return the token to the client
 
diff --git a/context/feature-specs/23-design-agent.logic.md b/context/feature-specs/23-design-agent.logic.md
new file mode 100644
index 0000000..202694f
--- /dev/null
+++ b/context/feature-specs/23-design-agent.logic.md
@@ -0,0 +1,52 @@
+Implement the full Ai design agent so a user prompt resultes in real-time updates to the collaborative canvas, with visible AI presence and status.
+
+## Implementation
+
+1. Update the design agent task in `trigger/design-agent.ts`
+
+    Befor implementing:
+    - check `context/project-overview.md` and `context\architecture-context.md` for product behavior and system resultes
+    - Before implementing, check Liveblock and Trigger.dev agent skills for current patterns on canvas mutation and background task execution
+    - follow the existing Trigger.dev setup and agent patterns already in the project
+    - reuse existing Liveblocks flow and presence patterns instead of creating new ones
+
+    Then implement:
+    - use Gemint(`@ai-sdk/google`) to interpret the user prompt
+    - update the canvas using the existing collaborative flow utilities
+    - support actions like:
+        - add node
+        - move node
+        - resize node
+        - update node data
+        - delete node
+        - add edge
+        - delete edge
+
+    - publish AI activity to the shared status feed so all users see progress
+    - update AI presence ( cursor + thinking rate) while the task runs
+    - push clear status messages at key steps ( start, processing, complete)
+    - ensure generated designs follow:
+        - allow node shapes
+        - color pallette
+        - layout and spacing rules
+
+    - handle errors gracefully and update status if something fails
+    - clear AI presense when the task finishes
+
+## Dependencies
+
+All packages are already installed.`GOOGLE_AI_API_KEY` is already in `env.local`
+
+## Scope Limits
+
+- don't change canvas architecture 
+- don't introduce a new state system outside Liveblocks
+- don't bypass existing collaborative flow utilities
+
+## Check When Done
+
+- Design task updates the canvas through the existing collaborative flow.
+- AI presence and status are visible to all participants.
+- Status message reflect task progress.
+- Errors are handled without breaking the canvas.
+- `npm run build` passes. 
diff --git a/context/feature-specs/24-ai-presense-state.md b/context/feature-specs/24-ai-presense-state.md
new file mode 100644
index 0000000..bc4e693
--- /dev/null
+++ b/context/feature-specs/24-ai-presense-state.md
@@ -0,0 +1,43 @@
+Add shared AI activity indicators so everyone in the room can see when generation is in progress. This unit is only for UI, presence, and realtime status signal. Do not all the actual AI generation flow yet.
+
+## Implementation
+
+1. Add AI thinking state to the sidebar.
+    - show a small status indicator when AI is working
+    - make the status visible to everyone in the room
+    - disable the chat input while generation is active
+    - show a loading state on the send button
+    - keep the rest of the sidbar usable
+
+2. Add a shared AI statut feed.
+    - check the existing Liveblocks setup and installed agent-related reature first
+    - follow Liveblocks best practices for feeds/presence instead of creating parallel realtime state
+    - create or reuse a Liveblocks feed name `ai-status-feed`
+    - subscribe to the latest feed message in the sidebar
+    - show only the most recent status message
+    - keep the feed generic enough for design and spec generation later
+
+3. Add status message validation.
+    - define the feed payload schema in `types/task.ts`
+    - the payload should support an option `text` field
+    - validate incoming messages before displaying them
+
+4. Add thinking indicators to live cursor.
+    - when a participation has `thinking:true` in presence, show a small spinner in their cursor name badge
+    - hide the spinner when `thinking` is false or missing
+
+## Scope Limits
+
+- don't add the actual AI generation logic
+- don't trigger background task yet
+- don't block or dim the whole sidebar
+- don't show full feed history
+- keep this focused on shared AI activity state only
+
+## Check When Done
+
+- Sidebar can render shared AI status from `ai-status-feed`
+- Chat input and send button respond to active generation state.
+- Cursor badges read `thinking` from presence.
+- Feed messages are validated through the task schema.
+- `npm run build` passes. 
diff --git a/context/feature-specs/25-sidebar-chat-feed.md b/context/feature-specs/25-sidebar-chat-feed.md
new file mode 100644
index 0000000..f03c483
--- /dev/null
+++ b/context/feature-specs/25-sidebar-chat-feed.md
@@ -0,0 +1,46 @@
+Add real-time room chat to the AI sidebard using a seperateLiveblocks `ai-chat` feed.
+
+This is only for the chat messages. Keep it seperate from `ai-status-feed`, which handles AI progress and presence updates.
+
+## Implementation
+
+1. Add the `ai-chat` feed.
+
+    Before implementing, check the existing Liveblocks setup and follow same feed patterns already used in the project.
+    - create or resuse a Liveblocks feed names `ai-chat`
+    - keep it room-scoped
+    - do not mix it with `ai-status-feed`
+
+2. Wire the chat feed into the sidebar.
+    - subscribe to `ai-chat` in the sidebar chat area 
+    - render the chat message in order 
+    - show sender, timestamp, and message content
+    - keep the styling consistent with the existing sidebar UI 
+    - use Tailwind utilities and existing shadcn components where they fit
+
+3. Add message sending. 
+    - allow users in the room to send message to `ai-chat`
+    - use the existing sidebar input and send button
+    - clear the input after a succesful send
+    - show a small error state if sending fails
+
+4. Add message validation.
+    - define or reuse a Zod schema in `types/task.ts`
+    - message shape should include sender, role, content, and timestamp
+    - validate feed message before rendering them
+
+## Scope Limits
+
+- don't add AI-generated replies yet
+- don't trigger backend AI tasks
+- don't mix chat messages with status messages
+- don't create a parallel realtime system outside Liveblocks
+- keep this focused on collaborative sidebar chat only
+
+## Check when done
+
+- Sidebar subscribe to the `ai-chat` feed. 
+- Users can send chat messages through the existing sidebar input.
+- Chat messages are validated before rendering.
+- `ai-chat` remains seperate from `ai-status-feed`
+- `npm run build` passes.
diff --git a/context/feature-specs/26-ai-chat-functional.md b/context/feature-specs/26-ai-chat-functional.md
new file mode 100644
index 0000000..fdb4ad9
--- /dev/null
+++ b/context/feature-specs/26-ai-chat-functional.md
@@ -0,0 +1,89 @@
+Wire up the AI sidebar so users can submit design prompts, 
+track AI run status in real time, and reflect AI-driven canvas updates through Liveblocks.
+
+## Implementation
+
+1. Submit from AI sidebar
+
+- on Submit:
+    - push the user message to the `ai-chat` feed
+    - call `POST /api/ai/design` with `{prompt, roomId}`
+    - read `{ runId, publicToken}` from the response
+- store `runId` and `publicToken` in local state
+
+2. Run status tracking
+
+- Use `useRealtimeRun( runId, { accessToken: publicToken })`
+- While the run is active:
+    - disable the chat input
+    - show a loading state ( spinner in the button is enough )
+- When the run completes
+    - push a final AI message to `ai-chat`
+    - reset loading + run state
+
+3. Canvas updates (realtime)
+
+- Do not manually update nodes/edges
+- Rely on Liveblocks (`useLiveblocksFlow`) to reflect changes in real time
+- AI updates to nodes, edges, and presence should appear automatically
+
+4. Status display
+
+- Read the latest message from `ai-status-feed`
+- Show a compact status strip above the input only when a run is active
+
+### UI Details
+
+- Use existing design tokens from `global.css` ( do not introduce new colors)
+- Follow `ui-context.md` for layout and visual consistency
+
+Chat bubbles
+
+- User: green accent background (`#62C073`)
+- AI: dark background, light text
+
+Submit button
+
+- Enabled: green accent (#62c073)
+- Disabled: dimmed state
+- While running: show spinner
+
+Status strip
+
+- Compact bar above input
+- Dark base + green accent
+- Subtle animated indicator is fine
+
+General
+
+- Use tailwind + shadcn/ui only
+- Keep current layout intact
+- Show errors as message in `ai-chat` feed
+
+### Scope limits
+
+- Do not implement backend or Trigger.dev logic
+- Do not fetch final graph data
+- Do not redesign the sidebar
+- Do not hardcode a new theme outside existing tokens
+- Do not manually sync canvas state
+
+---
+
+### Notes
+
+- Follow Liveblocks best practices for feeds (`ai-chat`, `ai-status-feed`)
+- Keep everything collaborative, all updates should be visible across clients
+
+---
+
+### Check When Done
+
+- Submitting a prompt calls `/api/ai/design` and returns a `runId`
+- `useRealtimeRun` connects using the returned tokens
+- Input is disabled while the run is active
+- Status strip appears only during active runs 
+- Chat updates appear across multiple sessions
+- No Typescript or build errors
+
+
diff --git a/context/feature-specs/27-spec-generation-flow.md b/context/feature-specs/27-spec-generation-flow.md
new file mode 100644
index 0000000..e39ffca
--- /dev/null
+++ b/context/feature-specs/27-spec-generation-flow.md
@@ -0,0 +1,74 @@
+Create the backend flow for AI-powered spec generation: API route, Trigger.dev task, token route, and run ownership tracking
+
+### Implementation
+
+1. Spec trigger route
+
+Create or update `POST /api/ai/spec`
+
+It should:
+
+- accept `roomId`, `chatHistory`, `nodes`, and `edges`
+- authenicate the current user
+- resolve project access from `roomId`
+- trigger the `generate-spec task 
+- save a `TaskRun` record for ownership/access control
+- return the Trigger.dev `runId`
+
+Do not trust a client-supplied `projectId`.
+
+2. Spec token route
+
+Create or update `POST /api/ai/spec/token`
+
+It should:
+
+- accept `runId`
+- authenicate the current user
+- verify the `TaskRun` belongs to the user
+- issue a Trigger.dev public acces token scoped to the that run
+- set token expiration to 1 hour
+- return the token to the client 
+
+3. Spec generation task 
+
+Create or update `trigger/generate-spec.ts`.
+Define a `generateSpec` task that:
+
+- accept `projectId`, `roomId`, `chatHistory`, `nodes`, and `edges`
+- validates input with Zod
+- use Gemini through `@ai-sdk/google`
+- generates a Markdown technical spec from the canvas and chat context
+- updates the run metadata/status for realtime tracking
+- return the generated spec content as task output
+
+Follow the existing Trigger.dev task patterns in the codebase for retries, loggig, and error handling
+
+### Scope Limits
+
+- Do not add frontend logic
+- Do not create spec editor UI
+- Do not store the final spec in this unit 
+- Do not derive access from teh client-provided project IDs
+- Do not create a new AI provider abstraction
+- Do not change exisiting canvas or chat data models
+
+### Notes
+
+- Check `context/project-overview.md` and `context/architecture-context.md` for system alignment before Implementation
+- Use Zod for request/task input validation
+- Use Prisma for `TaskRun` persistence
+- Project access must come from the authenticated user + `roomId`
+- Keep the task output as plain Markdown
+- Reuse the existing auth, Prisma, Trigger.dev, and Gemini patterns
+
+### Check When Done
+
+- `POST /api/ai/spec` validates input and returns a `runId`
+- A `TaskRun` record is created for the authenticated user
+- `POST /api/ai/spec/token` only returns a token for the run owner
+- `generate-spec` run through Trigger.dev and returns Markdown output
+- Typescript and build pass
+
+
+
diff --git a/context/feature-specs/28-spec-persistence-download.md b/context/feature-specs/28-spec-persistence-download.md
new file mode 100644
index 0000000..df3c345
--- /dev/null
+++ b/context/feature-specs/28-spec-persistence-download.md
@@ -0,0 +1,60 @@
+Persist generated specs with Vercel Blob and Prisma, then add a secure download route so users can retrieve their generated spec files.
+
+### Implementation
+
+1. ProjectSpec model
+
+Ensure a `ProjectSpec` Prisma model exists with:
+
+- `id`
+- `projectId` (relation to project)
+- `filePath` (Blob URL or path)
+- `createdAt`
+
+Use this model for metadata only. The actual spec content should live in Vercel Blob.
+
+2. Save generated spec
+
+After a spec is generated:
+
+- upload the Markdown content to Vercel Blob
+- store the Blob URL/path in `ProjectSpec.filePath`
+- link the record to the correct project
+- follow the same metadata + blob pattern used for canvas persistence
+
+3. Download route
+
+Create a route like: `GET /api/projects/[projectId]/specs/[specId]/download`
+
+It should:
+
+- authenticate the user
+- verify access to the project
+- verify the spec belongs to that project
+- fetch the file using `ProjectSpec.filePath`
+- return it as a downloadable Markdown file
+- handle not found and forbidden cases properly
+
+### Scope Limits
+
+- do not add frontend of UI logic
+- do not store spec content in Prisma
+- do not expose Blob URLs without access checks
+- do not modify exisitng canvas persistence
+
+### Notes
+- check `context/project-overview.md` and `context/architecture-context.md` first
+- reuse existing project access patterns
+- Prisma stores metadata, Vercel Blobs store content
+
+### Check when done 
+
+- `ProjectSpec` model exits with required fields
+- spec is uploaded to Vercel Blob
+- `filePath` is saved correctly
+- download route validates access before returning file
+- response is a Markdown attachment
+- Typescript and build pass
+
+
+
diff --git a/context/feature-specs/29-spec-ui-integration.md b/context/feature-specs/29-spec-ui-integration.md
new file mode 100644
index 0000000..c96dd3f
--- /dev/null
+++ b/context/feature-specs/29-spec-ui-integration.md
@@ -0,0 +1,55 @@
+Integrate spec generation results into the editor so users can view, preview, and download specs from the exiting ai sidebar specs tab.
+
+### Implementation
+
+1. Spec list
+
+- in the right sidebar ( Specs tab), show a list of specs for the current project
+- fetch spec from the backend using the existing ProjectSpec API
+- display:
+    - createdAt
+    - filename
+- keep items simple and clickable
+
+2. Preview modal
+
+- open a modal when a spec is selected
+- fetch the spec content through and existing endpoint( do not access Blob directly from the client)
+- render context as markdown
+- include a close action and basic keyboard support
+
+3. Download action
+
+- add a download action for each spec ( list item + modal)
+- call the download endpoint
+- let the browser handle the file download
+
+### UI Details
+
+- use existing sidebar layout, do not redesign
+- use shadcn.ui components ( Dialog, Scroll Area, Button)
+- use existing colors and tokesn from `global.css`
+- follow `ui-context.md` for spacing and layout
+- kepp the list compace the scrollable
+
+### Scope Limits
+
+- do not implement backend logic
+- do not fetch Blob URLS directly in the client
+- do not store spec content in the frontend state long-term
+- do not redesign the sidebar or tabs
+- do not add new global state
+
+### Notes
+
+- reuse existing fetch patterns used in the app
+- assume ProjectSpec only provided metadata, content must be fetched seperately
+
+### Check When Done
+
+- spec list loads for the current project
+- modal shows rendered Markdown content
+- download action triggers file download
+- TypeScript and build pass
+
+
diff --git a/context/progress-tracker.md b/context/progress-tracker.md
index 75b15d5..8255aaf 100644
--- a/context/progress-tracker.md
+++ b/context/progress-tracker.md
@@ -5,10 +5,20 @@ Update this file whenever the current phase, active feature, or implementation s
 ## Current Phase
 
 - Canvas autosave with Vercel Blob (spec 21 complete)
+- Design agent API backend wiring (spec 22 complete)
+- AI design agent logic with Gemini and Liveblocks canvas mutation (spec 23 complete)
+- Shared AI activity indicators (spec 24 complete)
+- Real-time room chat via ai-chat feed (spec 25 complete)
+- Functional AI chat submit + realtime run tracking (spec 26 complete)
+- Spec generation backend flow (spec 27 complete)
+- Spec persistence and download (spec 28 complete)
+- Spec UI integration (spec 29 complete)
 
 ## Current Goal
 
-- Persist canvas state between sessions using Vercel Blob + Prisma
+- AI design agent generates architecture from prompt, writes directly to Liveblocks room
+- Show shared AI activity state (status feed, thinking indicator, input gating)
+- Real-time chat in AI sidebar via dedicated Liveblocks ai-chat feed
 
 ## Completed
 
@@ -162,7 +172,99 @@ Update this file whenever the current phase, active feature, or implementation s
   - Added `BLOB_READ_WRITE_TOKEN` to `.env.local` for local dev
   - `npm run build` passes, `npx tsc --noEmit` passes
   - Check: no saved canvas loads if room already has nodes/edges (`loadedRef` + early return)
-  - Check: collaborators also authenticated via `auth()` (not owner-only); load returns 404 gracefully with empty `{ nodes: [], edges: [] }`
+   - Check: collaborators also authenticated via `auth()` (not owner-only); load returns 404 gracefully with empty `{ nodes: [], edges: [] }`
+- Design agent API backend wiring (spec 22):
+   - Installed `@trigger.dev/sdk@^4.4.6`, `@trigger.dev/build` (devDependency); `npx trigger.dev@latest init` created `trigger.config.ts` with project ref, `dirs: ["./src/trigger"]`, retry config
+    - Created `trigger/design-agent.ts` — minimal design task with `id: "design-agent"`, accepts `{ prompt, roomId }` payload, logs input via `logger.info`, returns ack; no AI logic yet per scope limits
+
+    - Created `prisma/models/task-run.prisma` — `TaskRun` model with `runId` (PK), `projectId`, `userId`, `createdAt`; indexes on `runId` and compound `[userId, projectId]`
+    - Created migration `20260528183903_add_task_run` — creates `TaskRun` table
+     - Created `app/api/ai/design/route.ts` — `POST` accepts `{ prompt, roomId, projectId }`, requires auth + project access, triggers `design-agent` task via `tasks.trigger()`, persists `TaskRun` record, returns `201 { runId }`
+   - Created `app/api/ai/design/token/route.ts` — `POST` accepts `{ runId }`, requires auth, looks up `TaskRun` by `runId`, verifies ownership (`taskRun.userId === userId`), generates Trigger.dev public access token scoped to that run via `auth.createPublicToken()`, returns `{ token }`
+   - Added `TRIGGER_SECRET_KEY` placeholder to `.env.local`; added `.trigger` to `.gitignore`
+    - `npm run build` passes — both routes registered in route manifest
+- AI design agent logic with Gemini and Liveblocks canvas mutation (spec 23):
+    - Installed `ai` and `@ai-sdk/google` packages
+    - Updated `trigger/design-agent.ts` — uses Gemini (`gemini-2.5-flash`) via `generateText` with `Output.object()` and a Zod schema for typed, validated structured output (eliminates fragile `JSON.parse`)
+    - System prompt constrains output to 6 allowed shapes, 8 color pairs, and layout rules
+    - AI presence uses Liveblocks ephemeral presence endpoint (`POST /v2/rooms/{roomId}/presence`) with TTL — AI appears in `useOthers` alongside real users with name/avatar/status; no persistent storage key needed
+    - Storage mutations use `mutateFlow()` from `@liveblocks/react-flow/node` — the official server-side API for React Flow mutations, uses `toLiveblocksInternalNode` with proper sync config (ensures 100% structural consistency with client-created nodes, preventing `setLocal` errors); replaced raw `liveblocks.mutateStorage()` + `LiveObject.from()`
+    - Supports add node, add edge operations in generated designs
+    - Task accepts `{ prompt, roomId, projectId, userId }` payload
+    - Errors are caught and logged without breaking the canvas
+    - `npm run build` passes
+
+- Shared AI activity indicators (spec 24):
+    - Added `AiStatusPayload` interface to `types/canvas.ts` with optional `text` field for feed message validation
+    - Created `AiStatusFeed` component inside `canvas.tsx` — subscribes to Liveblocks `ai-status-feed` via `useFeedMessages("ai-status-feed")`, creates the feed if missing via `useCreateFeed()`, passes latest message status to parent via `onAiStatusChange` callback
+    - Updated `workspace-shell.tsx` — manages `aiStatus` state, passes to `Canvas` (via `onAiStatusChange`) and `AiSidebar` (via `aiStatus` prop)
+    - Updated `ai-sidebar.tsx` — shows animated status badge in header with spinner + text when AI is working; disables chat textarea with "AI is working…" placeholder; shows `Loader2` spinner on send button during active generation; keeps rest of sidebar usable
+    - Updated `live-cursors.tsx` — `CursorPointer` reads `presence.isThinking` and renders a spinner SVG in the name badge when true
+    - Feed messages validated against `AiStatusPayload` schema before display
+    - `npm run build` passes
+
+- Real-time room chat via ai-chat feed (spec 25):
+    - Created `types/task.ts` with `AiChatMessageSchema` Zod schema (sender, role, content, timestamp) for feed message validation
+    - Updated `canvas.tsx` — added `isAiSidebarOpen`, `onAiSidebarClose`, `aiStatus` props; renders `<AiSidebar>` inside `RoomProvider` so it can use Liveblocks feed hooks
+    - Updated `workspace-shell.tsx` — removed direct `<AiSidebar>` rendering; passes sidebar state and `aiStatus` through `<Canvas>` props
+    - Updated `ai-sidebar.tsx` — replaced local `useState<ChatMessage[]>` with Liveblocks `ai-chat` feed via `useFeeds`/`useCreateFeed`/`useFeedMessages`/`useCreateFeedMessage`; validates incoming messages with `AiChatMessageSchema.safeParse()`; uses `useUser()` from Clerk for sender name; shows sender, timestamp, and error state
+    - Feed created on mount if missing (same pattern as `ai-status-feed`)
+    - `npm run build` passes
+
+- **Spec generation backend flow (spec 27)**:
+    - Created `trigger/generate-spec.ts` — Gemini-powered (`gemini-2.5-flash`) Markdown spec generation task
+    - Input validated with Zod: `projectId`, `roomId`, `chatHistory`, `nodes`, `edges`
+    - Builds a prompt from node labels/shapes/positions and edge connections with optional chat context
+    - System prompt instructs structured Markdown output: Overview, Architecture, Data Flow, Key Design Decisions, Recommendations
+    - Returns `{ spec: string, status: "complete" }` as task output
+    - Created `app/api/ai/spec/route.ts` — `POST` accepts `roomId`, `chatHistory`, `nodes`, `edges` (no client-supplied `projectId`)
+    - Resolves `projectId` from `roomId` via `getProjectAccess()` — rejects 403 if no access
+    - Triggers `generate-spec` task, persists `TaskRun` record, returns `{ runId }`
+    - Created `app/api/ai/spec/token/route.ts` — `POST` accepts `runId`, verifies ownership, issues Trigger.dev public token scoped to that run with `1h` expiration
+    - Follows same patterns as design agent routes (auth, Prisma, Trigger.dev, error handling)
+    - `npx tsc --noEmit` and `npm run build` pass
+
+- **Explicit node/edge sync config for `data` field**:
+    - Added `nodes: { sync: { canvasNode: { data: true } } }` and `edges: { sync: { canvasEdge: { data: true } } }` to `useLiveblocksFlow` in `canvas.tsx` — formally declares that all `data` sub-fields (label, color, textColor, shape) are synced, ensures `mutateFlow` uses the same config server-side via `buildNodeConfigCache`
+
+- **Spec persistence and download (spec 28)**:
+    - Created `prisma/models/spec.prisma` — `ProjectSpec` model (`id`, `projectId`, `filePath`, `createdAt`) with `@@index([projectId, createdAt])` and cascade delete
+    - Added `specs ProjectSpec[]` relation on `Project` model
+    - Updated `prisma/schema.prisma` to reference `spec.prisma`
+    - Created and applied migration `20260618230810_add_project_spec`
+    - Updated `trigger/generate-spec.ts` — after spec generation, creates `ProjectSpec` record, uploads markdown to Vercel Blob at `specs/{projectId}/{specId}.md`, updates record with blob URL; returns `specId` and `blobUrl` alongside spec
+    - Created `app/api/projects/[projectId]/specs/[specId]/download/route.ts` — authenticates via Clerk, verifies project access via `getProjectAccess()`, verifies spec belongs to project, fetches blob content, returns as `text/markdown` with `Content-Disposition: attachment` for browser download
+    - `npx tsc --noEmit` and `npm run build` pass
+
+- **Functional AI chat submit with realtime run tracking (spec 26)**:
+    - Installed `@trigger.dev/react-hooks@^4.4.6` for `useRealtimeRun` hook
+    - Updated `AiSidebar` props to accept `projectId` (same as `roomId`)
+    - Added `submitPrompt()` shared function called by both textarea send and starter chips
+    - Submit flow: push user message to `ai-chat` feed → `POST /api/ai/design` → `POST /api/ai/design/token` → store `runId` + `publicToken` in state
+    - `useRealtimeRun` subscribes to run status with public access token
+    - `onComplete` pushes AI result message to `ai-chat` feed and clears run state
+    - Chat input disabled and send button shows spinner while `isRunActive` (submitting or run in progress)
+    - Submit button uses `#62C073` green accent per spec; disabled state dimmed
+    - User chat bubbles use `#62C073` green background; AI bubbles use `bg-elevated` dark background
+    - Compact status strip above input during active runs: dark base, green left border accent, animated pulse dot, AI status text
+    - Errors pushed to `ai-chat` feed as "System" messages
+    - Canvas relies on Liveblocks `useLiveblocksFlow` for real-time updates — no manual node/edge sync
+    - Updated `Canvas` component to pass `projectId` to `AiSidebar`
+    - `npx tsc --noEmit` and `npm run build` pass
+
+- **Spec UI integration (spec 29)**:
+    - Created `GET /api/projects/[projectId]/specs` — lists project specs (id, filePath, createdAt) ordered by creation date desc; auth + project access enforced
+    - Created `GET /api/projects/[projectId]/specs/[specId]/content` — fetches spec markdown from Vercel Blob and returns `{ content: string }`; auth + project access + spec ownership enforced
+    - Installed `react-markdown` for client-side markdown rendering in preview modal
+    - Updated `ai-sidebar.tsx`:
+      - Specs tab now fetches real spec list on mount from `/api/projects/[projectId]/specs`
+      - Displays specs as compact clickable cards with truncated ID, date, and download button
+      - Shows loading spinner and empty state ("No specs yet. Generate one above.")
+      - Click opens a shadcn `Dialog` that fetches spec content from the content endpoint and renders as Markdown via `ReactMarkdown` inside a `ScrollArea`
+      - Download button on each list item and in the modal footer triggers browser download via temp anchor element pointing at the download endpoint
+      - Uses `prose prose-sm prose-invert` classes for markdown styling
+      - Preserved existing sidebar layout, tabs, and styling — no redesign per scope limits
+    - `npm run build` and `npx tsc --noEmit` pass
 
 ## Notes
 
@@ -188,3 +290,12 @@ Update this file whenever the current phase, active feature, or implementation s
 
 - Next.js 16 note: `priority` prop on `next/image` is deprecated in favor of `preload`
 - Generated `components/ui/*` files are not modified per spec instructions
+- API route groups under the same path prefix must use the same dynamic param name — `app/api/projects/[id]/` and `app/api/projects/[projectId]/` cause "You cannot use different slug names for the same dynamic path" errors. All specs routes were moved from `[projectId]` to `[id]` to resolve this.
+
+## Bugs Fixed
+
+- **Vercel Blob overwrite error**: `PUT /api/projects/[id]/canvas` was calling `put()` without `allowOverwrite: true`, causing autosave to fail on the second save. Fixed by adding the option — overwriting is safe since only the latest canvas state matters.
+- **Migration data loss**: Migration `20260528144727_rename_canvas_json_path_to_canvas_blob_url` used `DROP ... ADD` instead of `RENAME COLUMN`, which would drop existing data on fresh installs. Fixed the SQL and reset the dev database (wiping all existing projects). Users need to create new projects.
+- **`node.setLocal is not a function` when clicking AI-generated nodes**: Root cause was server-side nodes created via raw `LiveObject.from(node)` bypassing the sync config that `toLiveblocksInternalNode` applies. Nodes had correct `LiveObject` structure but differed in how the sync config (especially `data` field handling) was applied. Fixed by replacing `liveblocks.mutateStorage()` + `LiveObject.from()` with `mutateFlow()` from `@liveblocks/react-flow/node`, which uses `toLiveblocksInternalNode` with the proper `buildNodeConfigCache`-resolved sync config — structurally identical to client-created nodes. Also added explicit `nodes.sync`/`edges.sync` config for `data: true` to `useLiveblocksFlow` and `mutateFlow`   calls for consistency.
+- **Prisma client stale after adding `ProjectSpec` model**: The `ProjectSpec` model was added to `prisma/models/spec.prisma` and migrations were run, but `npx prisma generate` was not executed, leaving the generated client without the `projectSpec` delegate property. Any route calling `prisma.projectSpec.findMany()` threw `Cannot read properties of undefined (reading 'findMany')`. Fixed by running `npx prisma generate` to rebuild the client.
+- **"Generate Spec" button did nothing**: The button in `ai-sidebar.tsx` Specs tab had no `onClick` handler. Added `CanvasStateContext` in `canvas.tsx` to expose current nodes/edges from `FlowCanvas` to sibling `AiSidebar`. Wired `handleGenerateSpec` — calls `POST /api/ai/spec` with canvas state + chat history, subscribes via `useRealtimeRun` with public token, refreshes spec list on completion. Shows spinner/"Generating…" while run is active.
diff --git a/context/ui-context.md b/context/ui-context.md
index 3f18815..73f4fe3 100644
--- a/context/ui-context.md
+++ b/context/ui-context.md
@@ -2,29 +2,33 @@
 
 ## Theme
 
-Dark only. No light mode. The visual language is a dark technical workspace — near-black backgrounds, layered surfaces, and vivid accent colors for interactive elements.
+Supports both dark and light mode. Dark is the default. The visual language is a technical workspace — layered surfaces, minimal chrome, and vivid accent colors for interactive elements.
 
 All colors are defined as CSS custom properties in `globals.css` and mapped to Tailwind tokens via `@theme inline`. Components must use these tokens — no hardcoded hex values or raw Tailwind color classes like `zinc-*`.
 
-| Role             | CSS Variable           | Hex / Value               |
-| ---------------- | ---------------------- | ------------------------- |
-| Page background  | `--bg-base`            | `#080809`                 |
-| Surface          | `--bg-surface`         | `#111114`                 |
-| Elevated surface | `--bg-elevated`        | `#18181c`                 |
-| Subtle surface   | `--bg-subtle`          | `#1e1e23`                 |
-| Default border   | `--border-default`     | `#2a2a30`                 |
-| Subtle border    | `--border-subtle`      | `#3a3a42`                 |
-| Primary text     | `--text-primary`       | `#f0f0f4`                 |
-| Secondary text   | `--text-secondary`     | `#c0c0cc`                 |
-| Muted text       | `--text-muted`         | `#808090`                 |
-| Faint text       | `--text-faint`         | `#505060`                 |
-| Brand accent     | `--accent-primary`     | `#00c8d4` (cyan)          |
-| Brand dim        | `--accent-primary-dim` | `rgba(0, 200, 212, 0.12)` |
-| AI accent        | `--accent-ai`          | `#6457f9` (indigo-purple) |
-| AI text          | `--accent-ai-text`     | `#8b82ff`                 |
-| Error            | `--state-error`        | `#ff4d4f`                 |
-| Success          | `--state-success`      | `#34d399`                 |
-| Warning          | `--state-warning`      | `#fbbf24`                 |
+### Color Tokens
+
+| Role             | CSS Variable           | Dark                    | Light                   |
+| ---------------- | ---------------------- | ----------------------- | ----------------------- |
+| Page background  | `--bg-base`            | `#080809`               | `#f5f5f0`               |
+| Surface          | `--bg-surface`         | `#111114`               | `#ffffff`               |
+| Elevated surface | `--bg-elevated`        | `#18181c`               | `#f0efec`               |
+| Subtle surface   | `--bg-subtle`          | `#1e1e23`               | `#e8e7e4`               |
+| Default border   | `--border-default`     | `#2a2a30`               | `#d4d4d0`               |
+| Subtle border    | `--border-subtle`      | `#3a3a42`               | `#c0c0bc`               |
+| Primary text     | `--text-primary`       | `#f0f0f4`               | `#1a1a1e`               |
+| Secondary text   | `--text-secondary`     | `#c0c0cc`               | `#3a3a42`               |
+| Muted text       | `--text-muted`         | `#808090`               | `#808088`               |
+| Faint text       | `--text-faint`         | `#505060`               | `#b0b0b8`               |
+| Brand accent     | `--accent-primary`     | `#00c8d4` (cyan)        | `#00c8d4` (cyan)        |
+| Brand dim        | `--accent-primary-dim` | `rgba(0, 200, 212, 0.12)` | `rgba(0, 200, 212, 0.10)` |
+| AI accent        | `--accent-ai`          | `#6457f9` (indigo-purple) | `#6457f9` (indigo-purple) |
+| AI text          | `--accent-ai-text`     | `#8b82ff`               | `#6b60e0`               |
+| Error            | `--state-error`        | `#ff4d4f`               | `#e53e3e`               |
+| Success          | `--state-success`      | `#34d399`               | `#2da573`               |
+| Warning          | `--state-warning`      | `#fbbf24`               | `#d99f1c`               |
+
+Brand accent and AI accent remain the same across modes — they're vivid enough to read on both dark and light backgrounds. State colors are slightly adjusted in light mode for better contrast on pale surfaces.
 
 Tailwind utility names map to these variables. Use `bg-base`, `bg-surface`, `text-primary`, `text-muted`, `border-default`, `text-brand`, `bg-accent-primary-dim`, etc.
 
@@ -51,7 +55,7 @@ Radius increases with surface depth — smaller for inner elements, larger for o
 
 ## Node Color Palette
 
-8 defined color pairs. Each pair specifies a dark node fill and a vivid contrasting text color tuned for readability on the dark canvas. Defined in `types/canvas.ts` as `NODE_COLORS`.
+8 defined color pairs. Each pair specifies a node fill and a vivid contrasting text color tuned for readability on the canvas. Designed for the dark canvas (default) — light mode uses the same palette since nodes are consistently dark-backed for visual weight regardless of surrounding UI mode. Defined in `types/canvas.ts` as `NODE_COLORS`.
 
 | Node fill | Text color | Character              |
 | --------- | ---------- | ---------------------- |
@@ -87,7 +91,7 @@ Small white circular handles, hidden by default, revealed on node hover. Appear
 
 ### Canvas Background
 
-React Flow `<Background>` component. Canvas sits on the base background color.
+React Flow `<Background>` component. Canvas sits on the base background color, which adapts to the active theme (near-black in dark mode, off-white in light mode). The dot pattern uses a subtle contrast color that works in both modes.
 
 ## Component Library
 
@@ -96,9 +100,9 @@ shadcn/ui on top of Tailwind. No custom design system. Components live in `compo
 ## Layout Patterns
 
 - Editor workspace: full-viewport layout — floating sidebar overlay on the left, center canvas, slide-over AI sidebar on the right.
-- Sidebars: floating overlay with dark semi-transparent background and subtle border.
-- Modals and dialogs: centered overlay, `rounded-3xl`, dark background with backdrop blur.
-- Navbar: top bar with dark background and bottom border.
+- Sidebars: floating overlay with semi-transparent background (`bg-base/95` in dark, `bg-base/90` in light) and subtle border.
+- Modals and dialogs: centered overlay, `rounded-3xl`, elevated surface background with backdrop blur.
+- Navbar: top bar with surface background and bottom border.
 
 ## Icons
 
diff --git a/package-lock.json b/package-lock.json
index c037af3..b5f1ef3 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,21 +8,26 @@
       "name": "ghostai",
       "version": "0.1.0",
       "dependencies": {
+        "@ai-sdk/google": "^3.0.80",
         "@clerk/nextjs": "^7.3.4",
         "@clerk/ui": "^1.10.0",
-        "@liveblocks/client": "^3.19.2",
-        "@liveblocks/react": "^3.19.2",
-        "@liveblocks/react-flow": "^3.19.2",
-        "@liveblocks/react-ui": "^3.19.2",
+        "@liveblocks/client": "^3.19.3",
+        "@liveblocks/node": "^3.19.3",
+        "@liveblocks/react": "^3.19.3",
+        "@liveblocks/react-flow": "^3.19.3",
+        "@liveblocks/react-ui": "^3.19.3",
         "@prisma/adapter-pg": "^7.8.0",
         "@prisma/client": "^7.8.0",
         "@radix-ui/react-dialog": "^1.1.15",
         "@radix-ui/react-scroll-area": "^1.2.10",
         "@radix-ui/react-slot": "^1.2.4",
         "@radix-ui/react-tabs": "^1.1.13",
+        "@trigger.dev/react-hooks": "^4.4.6",
+        "@trigger.dev/sdk": "^4.4.6",
         "@types/pg": "^8.20.0",
         "@vercel/blob": "^2.4.0",
         "@xyflow/react": "^12.10.2",
+        "ai": "^6.0.193",
         "class-variance-authority": "^0.7.1",
         "clsx": "^2.1.1",
         "dotenv": "^17.4.2",
@@ -32,11 +37,13 @@
         "prisma": "^7.8.0",
         "react": "19.2.4",
         "react-dom": "19.2.4",
+        "react-markdown": "^10.1.0",
         "tailwind-merge": "^3.6.0",
         "tsx": "^4.22.3"
       },
       "devDependencies": {
         "@tailwindcss/postcss": "^4",
+        "@trigger.dev/build": "^4.4.6",
         "@types/node": "^20",
         "@types/react": "^19",
         "@types/react-dom": "^19",
@@ -46,6 +53,68 @@
         "typescript": "^5"
       }
     },
+    "node_modules/@ai-sdk/gateway": {
+      "version": "3.0.121",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/gateway/-/gateway-3.0.121.tgz",
+      "integrity": "sha512-uY248djJRxa5W68MHiyqO8WLdOeKQoRClGg7PVX/VPhVW8SJNM7/l5DcrA5WAM3YfQrLyNkgZa2VOu8T0t8LUw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "3.0.10",
+        "@ai-sdk/provider-utils": "4.0.27",
+        "@vercel/oidc": "3.2.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
+    "node_modules/@ai-sdk/google": {
+      "version": "3.0.80",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/google/-/google-3.0.80.tgz",
+      "integrity": "sha512-5ORbm/yFUPO0MEvZsxBMN0cdKw2+lwU/wVn5KN3KF8Dmk1LughuDuUohMh/7iU/XFTiyB0OvmTW/tdV/J7O9zg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "3.0.10",
+        "@ai-sdk/provider-utils": "4.0.27"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
+    "node_modules/@ai-sdk/provider": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider/-/provider-3.0.10.tgz",
+      "integrity": "sha512-Q3BZ27qfpYqnCYGvE3vt+Qi6LGOF9R5Nmzn+9JoM1lCRsD9mYaIhfJLkSunN48nfGXJ6n+XNV0J/XVpqGQl7Dw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "json-schema": "^0.4.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@ai-sdk/provider-utils": {
+      "version": "4.0.27",
+      "resolved": "https://registry.npmjs.org/@ai-sdk/provider-utils/-/provider-utils-4.0.27.tgz",
+      "integrity": "sha512-ubkAJ+xODouwtmN1tYlvTPphH1hPOBfZaEQe8U7skGvFAnIRs9PPpsq57bC2+Ky/MB4yzhd6YOsxTAx9sGpazw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/provider": "3.0.10",
+        "@standard-schema/spec": "^1.1.0",
+        "eventsource-parser": "^3.0.8"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
     "node_modules/@alloc/quick-lru": {
       "version": "5.2.0",
       "dev": true,
@@ -266,6 +335,12 @@
         "node": ">=6.9.0"
       }
     },
+    "node_modules/@bugsnag/cuid": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/@bugsnag/cuid/-/cuid-3.2.2.tgz",
+      "integrity": "sha512-7onuYLTMqMmHE9BBPG0YER4nFsU1rB+me1/YIeMusqcLbVbKKuG9u9+BDVDpje5e0llkkrVNOKYwmzM9DRIo7A==",
+      "license": "MIT"
+    },
     "node_modules/@clerk/backend": {
       "version": "3.4.11",
       "license": "MIT",
@@ -436,6 +511,18 @@
       "version": "3.1.3",
       "license": "MIT"
     },
+    "node_modules/@electric-sql/client": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/@electric-sql/client/-/client-1.0.14.tgz",
+      "integrity": "sha512-LtPAfeMxXRiYS0hyDQ5hue2PjljUiK9stvzsVyVb4nwxWQxfOWTSF42bHTs/o5i3x1T4kAQ7mwHpxa4A+f8X7Q==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@microsoft/fetch-event-source": "^2.0.1"
+      },
+      "optionalDependencies": {
+        "@rollup/rollup-darwin-arm64": "^4.18.1"
+      }
+    },
     "node_modules/@electric-sql/pglite": {
       "version": "0.4.1",
       "license": "Apache-2.0"
@@ -1184,6 +1271,15 @@
       "version": "0.8.4",
       "license": "MIT"
     },
+    "node_modules/@google-cloud/precise-date": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/@google-cloud/precise-date/-/precise-date-4.0.0.tgz",
+      "integrity": "sha512-1TUx3KdaU3cN7nfCdNf+UVqA/PSX29Cjcox3fZZBtINlRrXVTmUkQnCKv2MbBUbCopbK4olAT1IHl76uZyCiVA==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=14.0.0"
+      }
+    },
     "node_modules/@hono/node-server": {
       "version": "1.19.11",
       "license": "MIT",
@@ -1837,8 +1933,16 @@
         "@jridgewell/sourcemap-codec": "^1.4.14"
       }
     },
+    "node_modules/@jsonhero/path": {
+      "version": "1.0.21",
+      "resolved": "https://registry.npmjs.org/@jsonhero/path/-/path-1.0.21.tgz",
+      "integrity": "sha512-gVUDj/92acpVoJwsVJ/RuWOaHyG4oFzn898WNGQItLCTQ+hOaVlEaImhwE1WqOTf+l3dGOUkbSiVKlb3q1hd1Q==",
+      "license": "MIT"
+    },
     "node_modules/@juggle/resize-observer": {
       "version": "3.4.0",
+      "resolved": "https://registry.npmjs.org/@juggle/resize-observer/-/resize-observer-3.4.0.tgz",
+      "integrity": "sha512-dfLbk+PwWvFzSxwk3n5ySL0hfBog779o8h68wK/7/APo/7cgyWp5jcXockbxdk5kFRkbeXWm4Fbi9FrdN381sA==",
       "license": "Apache-2.0"
     },
     "node_modules/@kurkle/color": {
@@ -1846,25 +1950,44 @@
       "license": "MIT"
     },
     "node_modules/@liveblocks/client": {
-      "version": "3.19.2",
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/client/-/client-3.19.3.tgz",
+      "integrity": "sha512-3w8yo2YJWoWkkReBS2NHfQTt5JxqPFtSCLG0OyWLwEQvKNN4syogC9cA6xaz4U7YKKVcT1R5n4MOnUUV4/q9Xg==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@liveblocks/core": "3.19.2"
+        "@liveblocks/core": "3.19.3"
       }
     },
     "node_modules/@liveblocks/core": {
-      "version": "3.19.2",
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/core/-/core-3.19.3.tgz",
+      "integrity": "sha512-SR3QsXoVapJmMUI0RDaVuHZMllJIyrFw+9Gj7atZaq2Tpdf1qANzaBWrI2Jij85/tsqYA46T8ouQnzOhvZKzpQ==",
       "license": "Apache-2.0",
       "peerDependencies": {
         "@types/json-schema": "^7"
       }
     },
+    "node_modules/@liveblocks/node": {
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/node/-/node-3.19.3.tgz",
+      "integrity": "sha512-TF4FJ1BRMqnZ1ofVcpIWowjWZf5ZeGR/Ej01GXQA/4J4ukuLSD4AXUqZA1fZox64gbpopolSCx8Q1BgKhAfRwA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@liveblocks/core": "3.19.3",
+        "@stablelib/base64": "^1.0.1",
+        "fast-sha256": "^1.3.0",
+        "marked": "^15.0.11",
+        "node-fetch": "^2.6.1"
+      }
+    },
     "node_modules/@liveblocks/react": {
-      "version": "3.19.2",
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/react/-/react-3.19.3.tgz",
+      "integrity": "sha512-FcLSiYK34gtfzmXk6Pcec60dIQBxH2SAlIxUESr68rlMS+R5Gcydww2EYJQt4+jbdeQZcPuNU+oEoiq3fHlZ5Q==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@liveblocks/client": "3.19.2",
-        "@liveblocks/core": "3.19.2"
+        "@liveblocks/client": "3.19.3",
+        "@liveblocks/core": "3.19.3"
       },
       "peerDependencies": {
         "@types/react": "^18 || ^19",
@@ -1881,13 +2004,15 @@
       }
     },
     "node_modules/@liveblocks/react-flow": {
-      "version": "3.19.2",
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/react-flow/-/react-flow-3.19.3.tgz",
+      "integrity": "sha512-k3Vi255xnlM1PNmzib662u7F7UoDzY2TcNzMfYoQ+BYpt6XxXFh1I8hqEVT0RTt2w3tAfHz/Qa76/VSHdV711Q==",
       "license": "Apache-2.0",
       "dependencies": {
-        "@liveblocks/client": "3.19.2",
-        "@liveblocks/core": "3.19.2",
-        "@liveblocks/react": "3.19.2",
-        "@liveblocks/react-ui": "3.19.2"
+        "@liveblocks/client": "3.19.3",
+        "@liveblocks/core": "3.19.3",
+        "@liveblocks/react": "3.19.3",
+        "@liveblocks/react-ui": "3.19.3"
       },
       "peerDependencies": {
         "@xyflow/react": "^12",
@@ -1904,13 +2029,15 @@
       }
     },
     "node_modules/@liveblocks/react-ui": {
-      "version": "3.19.2",
+      "version": "3.19.3",
+      "resolved": "https://registry.npmjs.org/@liveblocks/react-ui/-/react-ui-3.19.3.tgz",
+      "integrity": "sha512-O0wFN/FJBxBkyz3RZlxZ6q4tazyFqQhE0Bu0hd4uycsU9mOu3Szx843IjjRVmeXtqlVcC7uMvynjZdmiaEtftA==",
       "license": "Apache-2.0",
       "dependencies": {
         "@floating-ui/react-dom": "^2.1.0",
-        "@liveblocks/client": "3.19.2",
-        "@liveblocks/core": "3.19.2",
-        "@liveblocks/react": "3.19.2",
+        "@liveblocks/client": "3.19.3",
+        "@liveblocks/core": "3.19.3",
+        "@liveblocks/react": "3.19.3",
         "frimousse": "^0.2.0",
         "marked": "^15.0.11",
         "radix-ui": "^1.4.0",
@@ -1934,6 +2061,12 @@
         }
       }
     },
+    "node_modules/@microsoft/fetch-event-source": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@microsoft/fetch-event-source/-/fetch-event-source-2.0.1.tgz",
+      "integrity": "sha512-W6CLUJ2eBMw3Rec70qrsEW0jOm/3twwJv21mrmj2yORiaVmVYGS4sSS5yUwvQc1ZlDLYGPnClVWmUUMagKNsfA==",
+      "license": "MIT"
+    },
     "node_modules/@napi-rs/wasm-runtime": {
       "version": "1.1.4",
       "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.4.tgz",
@@ -2166,6 +2299,272 @@
         "node": ">=12.4.0"
       }
     },
+    "node_modules/@opentelemetry/api": {
+      "version": "1.9.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/api/-/api-1.9.0.tgz",
+      "integrity": "sha512-3giAOQvZiH5F9bMlMiv8+GSPMeqg0dbaeo58/0SlA9sxSqZhnUtxzX9/2FzyhS9sWQf5S0GJE0AKBrFqjpeYcg==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/@opentelemetry/api-logs": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/api-logs/-/api-logs-0.203.0.tgz",
+      "integrity": "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      }
+    },
+    "node_modules/@opentelemetry/context-async-hooks": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/context-async-hooks/-/context-async-hooks-2.0.1.tgz",
+      "integrity": "sha512-XuY23lSI3d4PEqKA+7SLtAgwqIfc6E/E9eAQWLN1vlpC53ybO3o6jW4BsXo1xvz9lYyyWItfQDDLzezER01mCw==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.0.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/core": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/core/-/core-2.0.1.tgz",
+      "integrity": "sha512-MaZk9SJIDgo1peKevlbhP6+IwIiNPNmswNL4AF0WaQJLbHXjr9SrZMgS12+iqr9ToV4ZVosCcc0f8Rg67LXjxw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/semantic-conventions": "^1.29.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.0.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/exporter-logs-otlp-http": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/exporter-logs-otlp-http/-/exporter-logs-otlp-http-0.203.0.tgz",
+      "integrity": "sha512-s0hys1ljqlMTbXx2XiplmMJg9wG570Z5lH7wMvrZX6lcODI56sG4HL03jklF63tBeyNwK2RV1/ntXGo3HgG4Qw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api-logs": "0.203.0",
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/otlp-exporter-base": "0.203.0",
+        "@opentelemetry/otlp-transformer": "0.203.0",
+        "@opentelemetry/sdk-logs": "0.203.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/exporter-metrics-otlp-http": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/exporter-metrics-otlp-http/-/exporter-metrics-otlp-http-0.203.0.tgz",
+      "integrity": "sha512-HFSW10y8lY6BTZecGNpV3GpoSy7eaO0Z6GATwZasnT4bEsILp8UJXNG5OmEsz4SdwCSYvyCbTJdNbZP3/8LGCQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/otlp-exporter-base": "0.203.0",
+        "@opentelemetry/otlp-transformer": "0.203.0",
+        "@opentelemetry/resources": "2.0.1",
+        "@opentelemetry/sdk-metrics": "2.0.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/exporter-trace-otlp-http": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/exporter-trace-otlp-http/-/exporter-trace-otlp-http-0.203.0.tgz",
+      "integrity": "sha512-ZDiaswNYo0yq/cy1bBLJFe691izEJ6IgNmkjm4C6kE9ub/OMQqDXORx2D2j8fzTBTxONyzusbaZlqtfmyqURPw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/otlp-exporter-base": "0.203.0",
+        "@opentelemetry/otlp-transformer": "0.203.0",
+        "@opentelemetry/resources": "2.0.1",
+        "@opentelemetry/sdk-trace-base": "2.0.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/host-metrics": {
+      "version": "0.37.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/host-metrics/-/host-metrics-0.37.0.tgz",
+      "integrity": "sha512-gf6nRFci0PTni9R1QQKjZ2uZE4Y6olLKhlwdM0qqLbbn3SBVKyP2jyBMiosBTHtRNLjY7s8hzQ44eLdK5wkGNQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "systeminformation": "5.23.8"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/instrumentation": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/instrumentation/-/instrumentation-0.203.0.tgz",
+      "integrity": "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api-logs": "0.203.0",
+        "import-in-the-middle": "^1.8.1",
+        "require-in-the-middle": "^7.1.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/otlp-exporter-base": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/otlp-exporter-base/-/otlp-exporter-base-0.203.0.tgz",
+      "integrity": "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/otlp-transformer": "0.203.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/otlp-transformer": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/otlp-transformer/-/otlp-transformer-0.203.0.tgz",
+      "integrity": "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api-logs": "0.203.0",
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/resources": "2.0.1",
+        "@opentelemetry/sdk-logs": "0.203.0",
+        "@opentelemetry/sdk-metrics": "2.0.1",
+        "@opentelemetry/sdk-trace-base": "2.0.1",
+        "protobufjs": "^7.3.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": "^1.3.0"
+      }
+    },
+    "node_modules/@opentelemetry/resources": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/resources/-/resources-2.0.1.tgz",
+      "integrity": "sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/semantic-conventions": "^1.29.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.3.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/sdk-logs": {
+      "version": "0.203.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-logs/-/sdk-logs-0.203.0.tgz",
+      "integrity": "sha512-vM2+rPq0Vi3nYA5akQD2f3QwossDnTDLvKbea6u/A2NZ3XDkPxMfo/PNrDoXhDUD/0pPo2CdH5ce/thn9K0kLw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api-logs": "0.203.0",
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/resources": "2.0.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.4.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/sdk-metrics": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-metrics/-/sdk-metrics-2.0.1.tgz",
+      "integrity": "sha512-wf8OaJoSnujMAHWR3g+/hGvNcsC16rf9s1So4JlMiFaFHiE4HpIA3oUh+uWZQ7CNuK8gVW/pQSkgoa5HkkOl0g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/resources": "2.0.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.9.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/sdk-trace-base": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-base/-/sdk-trace-base-2.0.1.tgz",
+      "integrity": "sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/resources": "2.0.1",
+        "@opentelemetry/semantic-conventions": "^1.29.0"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.3.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/sdk-trace-node": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/sdk-trace-node/-/sdk-trace-node-2.0.1.tgz",
+      "integrity": "sha512-UhdbPF19pMpBtCWYP5lHbTogLWx9N0EBxtdagvkn5YtsAnCBZzL7SjktG+ZmupRgifsHMjwUaCCaVmqGfSADmA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/context-async-hooks": "2.0.1",
+        "@opentelemetry/core": "2.0.1",
+        "@opentelemetry/sdk-trace-base": "2.0.1"
+      },
+      "engines": {
+        "node": "^18.19.0 || >=20.6.0"
+      },
+      "peerDependencies": {
+        "@opentelemetry/api": ">=1.0.0 <1.10.0"
+      }
+    },
+    "node_modules/@opentelemetry/semantic-conventions": {
+      "version": "1.36.0",
+      "resolved": "https://registry.npmjs.org/@opentelemetry/semantic-conventions/-/semantic-conventions-1.36.0.tgz",
+      "integrity": "sha512-TtxJSRD8Ohxp6bKkhrm27JRHAxPczQA7idtcTOMYI+wQRRrfgqxHv1cFbCApcSnNjtXkmzFozn6jQtFrOmbjPQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=14"
+      }
+    },
     "node_modules/@prisma/adapter-pg": {
       "version": "7.8.0",
       "license": "Apache-2.0",
@@ -2348,6 +2747,75 @@
         "react-dom": "^18.0.0 || ^19.0.0"
       }
     },
+    "node_modules/@protobuf-ts/runtime": {
+      "version": "2.11.1",
+      "resolved": "https://registry.npmjs.org/@protobuf-ts/runtime/-/runtime-2.11.1.tgz",
+      "integrity": "sha512-KuDaT1IfHkugM2pyz+FwiY80ejWrkH1pAtOBOZFuR6SXEFTsnb/jiQWQ1rCIrcKx2BtyxnxW6BWwsVSA/Ie+WQ==",
+      "license": "(Apache-2.0 AND BSD-3-Clause)"
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
+      "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
+      "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
+      "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/inquire": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/inquire/-/inquire-1.1.2.tgz",
+      "integrity": "sha512-pa0vFRuws4wkvaXKK1uXZMAwAX4/t8ANaJo45iw/oQHNQ9q5xUzwgFmVJGXiga2BeN+zpX7Vf9vmsiIa2J+MUw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.1.tgz",
+      "integrity": "sha512-oOAWABowe8EAbMyWKM0tYDKi8Yaox52D+HWZhAIJqQXbqe0xI/GV7FhLWqlEKreMkfDjshR5FKgi3mnle0h6Eg==",
+      "license": "BSD-3-Clause"
+    },
     "node_modules/@radix-ui/number": {
       "version": "1.1.1",
       "license": "MIT"
@@ -2358,6 +2826,8 @@
     },
     "node_modules/@radix-ui/react-accessible-icon": {
       "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-accessible-icon/-/react-accessible-icon-1.1.7.tgz",
+      "integrity": "sha512-XM+E4WXl0OqUJFovy6GjmxxFyx9opfCAIUku4dlKRd5YEPqt4kALOkQOp0Of6reHuUkJuiPBEc5k0o4z4lTC8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-visually-hidden": "1.2.3"
@@ -2379,6 +2849,8 @@
     },
     "node_modules/@radix-ui/react-accordion": {
       "version": "1.2.12",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-accordion/-/react-accordion-1.2.12.tgz",
+      "integrity": "sha512-T4nygeh9YE9dLRPhAHSeOZi7HBXo+0kYIPJXayZfvWOWA0+n3dESrZbjfDPUABkUNym6Hd+f2IR113To8D2GPA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2408,6 +2880,8 @@
     },
     "node_modules/@radix-ui/react-alert-dialog": {
       "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-alert-dialog/-/react-alert-dialog-1.1.15.tgz",
+      "integrity": "sha512-oTVLkEw5GpdRe29BqJ0LSDFWI3qu0vR1M0mUkOQWDIUnY/QIkLpgDMWuKxP94c2NAC2LGcgVhG1ImF3jkZ5wXw==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2434,6 +2908,8 @@
     },
     "node_modules/@radix-ui/react-alert-dialog/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -2450,6 +2926,8 @@
     },
     "node_modules/@radix-ui/react-arrow": {
       "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-arrow/-/react-arrow-1.1.7.tgz",
+      "integrity": "sha512-F+M1tLhO+mlQaOWspE8Wstg+z6PwxwRd8oQ8IXceWz92kfAmalTRf0EjrouQeo7QssEPfCn05B4Ihs1K9WQ/7w==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-primitive": "2.1.3"
@@ -2471,6 +2949,8 @@
     },
     "node_modules/@radix-ui/react-aspect-ratio": {
       "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-aspect-ratio/-/react-aspect-ratio-1.1.7.tgz",
+      "integrity": "sha512-Yq6lvO9HQyPwev1onK1daHCHqXVLzPhSVjmsNjCa2Zcxy2f7uJD2itDtxknv6FzAKCwD1qQkeVDmX/cev13n/g==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-primitive": "2.1.3"
@@ -2492,6 +2972,8 @@
     },
     "node_modules/@radix-ui/react-avatar": {
       "version": "1.1.10",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-avatar/-/react-avatar-1.1.10.tgz",
+      "integrity": "sha512-V8piFfWapM5OmNCXTzVQY+E1rDa53zY+MQ4Y7356v4fFz6vqCyUtIz2rUD44ZEdwg78/jKmMJHj07+C/Z/rcog==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-context": "1.1.2",
@@ -2517,6 +2999,8 @@
     },
     "node_modules/@radix-ui/react-checkbox": {
       "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-checkbox/-/react-checkbox-1.3.3.tgz",
+      "integrity": "sha512-wBbpv+NQftHDdG86Qc0pIyXk5IR3tM8Vd0nWLKDcX8nNn4nXFOFwsKuqw2okA/1D/mpaAkmuyndrPJTYDNZtFw==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2545,6 +3029,8 @@
     },
     "node_modules/@radix-ui/react-collapsible": {
       "version": "1.1.12",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-collapsible/-/react-collapsible-1.1.12.tgz",
+      "integrity": "sha512-Uu+mSh4agx2ib1uIGPP4/CKNULyajb3p92LsVXmH2EHVMTfZWpll88XJ0j4W0z3f8NK1eYl1+Mf/szHPmcHzyA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2639,6 +3125,8 @@
     },
     "node_modules/@radix-ui/react-context-menu": {
       "version": "2.2.16",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-context-menu/-/react-context-menu-2.2.16.tgz",
+      "integrity": "sha512-O8morBEW+HsVG28gYDZPTrT9UUovQUlJue5YO836tiTJhuIWBm/zQHc7j388sHWtdH/xUZurK9olD2+pcqx5ww==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2753,6 +3241,8 @@
     },
     "node_modules/@radix-ui/react-dropdown-menu": {
       "version": "2.1.16",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-dropdown-menu/-/react-dropdown-menu-2.1.16.tgz",
+      "integrity": "sha512-1PLGQEynI/3OX/ftV54COn+3Sud/Mn8vALg2rWnBLnRaGtJDduNW/22XjlGgPdpcIbiQxjKtb7BkcjP00nqfJw==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2816,6 +3306,8 @@
     },
     "node_modules/@radix-ui/react-form": {
       "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-form/-/react-form-0.1.8.tgz",
+      "integrity": "sha512-QM70k4Zwjttifr5a4sZFts9fn8FzHYvQ5PiB19O2HsYibaHSVt9fH9rzB0XZo/YcM+b7t/p7lYCT/F5eOeF5yQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2842,6 +3334,8 @@
     },
     "node_modules/@radix-ui/react-hover-card": {
       "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-hover-card/-/react-hover-card-1.1.15.tgz",
+      "integrity": "sha512-qgTkjNT1CfKMoP0rcasmlH2r1DAiYicWsDsufxl940sT2wHNEWWv6FMWIQXWhVdmC1d/HYfbhQx60KYyAtKxjg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2887,6 +3381,8 @@
     },
     "node_modules/@radix-ui/react-label": {
       "version": "2.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-label/-/react-label-2.1.7.tgz",
+      "integrity": "sha512-YT1GqPSL8kJn20djelMX7/cTRp/Y9w5IZHvfxQTVHrOqa2yMl7i/UfMqKRU5V7mEyKTrUVgJXhNQPVCG8PBLoQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-primitive": "2.1.3"
@@ -2908,6 +3404,8 @@
     },
     "node_modules/@radix-ui/react-menu": {
       "version": "2.1.16",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-menu/-/react-menu-2.1.16.tgz",
+      "integrity": "sha512-72F2T+PLlphrqLcAotYPp0uJMr5SjP5SL01wfEspJbru5Zs5vQaSHb4VB3ZMJPimgHHCHG7gMOeOB9H3Hdmtxg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2946,6 +3444,8 @@
     },
     "node_modules/@radix-ui/react-menu/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -2962,6 +3462,8 @@
     },
     "node_modules/@radix-ui/react-menubar": {
       "version": "1.1.16",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-menubar/-/react-menubar-1.1.16.tgz",
+      "integrity": "sha512-EB1FktTz5xRRi2Er974AUQZWg2yVBb1yjip38/lgwtCVRd3a+maUoGHN/xs9Yv8SY8QwbSEb+YrxGadVWbEutA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -2992,6 +3494,8 @@
     },
     "node_modules/@radix-ui/react-navigation-menu": {
       "version": "1.2.14",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-navigation-menu/-/react-navigation-menu-1.2.14.tgz",
+      "integrity": "sha512-YB9mTFQvCOAQMHU+C/jVl96WmuWeltyUEpRJJky51huhds5W2FQr1J8D/16sQlf0ozxkPK8uF3niQMdUwZPv5w==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3026,6 +3530,8 @@
     },
     "node_modules/@radix-ui/react-one-time-password-field": {
       "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-one-time-password-field/-/react-one-time-password-field-0.1.8.tgz",
+      "integrity": "sha512-ycS4rbwURavDPVjCb5iS3aG4lURFDILi6sKI/WITUMZ13gMmn/xGjpLoqBAalhJaDk8I3UbCM5GzKHrnzwHbvg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/number": "1.1.1",
@@ -3058,6 +3564,8 @@
     },
     "node_modules/@radix-ui/react-password-toggle-field": {
       "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-password-toggle-field/-/react-password-toggle-field-0.1.3.tgz",
+      "integrity": "sha512-/UuCrDBWravcaMix4TdT+qlNdVwOM1Nck9kWx/vafXsdfj1ChfhOdfi3cy9SGBpWgTXwYCuboT/oYpJy3clqfw==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3086,6 +3594,8 @@
     },
     "node_modules/@radix-ui/react-popover": {
       "version": "1.1.15",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-popover/-/react-popover-1.1.15.tgz",
+      "integrity": "sha512-kr0X2+6Yy/vJzLYJUPCZEc8SfQcf+1COFoAqauJm74umQhta9M7lNJHP7QQS3vkvcGLQUbWpMzwrXYwrYztHKA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3121,6 +3631,8 @@
     },
     "node_modules/@radix-ui/react-popover/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -3137,6 +3649,8 @@
     },
     "node_modules/@radix-ui/react-popper": {
       "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-popper/-/react-popper-1.2.8.tgz",
+      "integrity": "sha512-0NJQ4LFFUuWkE7Oxf0htBKS6zLkkjBH+hM1uk7Ng705ReR8m/uelduy1DBo0PyBXPKVnBA6YBlU94MBGXrSBCw==",
       "license": "MIT",
       "dependencies": {
         "@floating-ui/react-dom": "^2.0.0",
@@ -3248,6 +3762,8 @@
     },
     "node_modules/@radix-ui/react-progress": {
       "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-progress/-/react-progress-1.1.7.tgz",
+      "integrity": "sha512-vPdg/tF6YC/ynuBIJlk1mm7Le0VgW6ub6J2UWnTQ7/D23KXcPI1qy+0vBkgKgd38RCMJavBXpB83HPNFMTb0Fg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-context": "1.1.2",
@@ -3270,6 +3786,8 @@
     },
     "node_modules/@radix-ui/react-radio-group": {
       "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-radio-group/-/react-radio-group-1.3.8.tgz",
+      "integrity": "sha512-VBKYIYImA5zsxACdisNQ3BjCBfmbGH3kQlnFVqlWU4tXwjy7cGX8ta80BcrO+WJXIn5iBylEH3K6ZTlee//lgQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3358,6 +3876,8 @@
     },
     "node_modules/@radix-ui/react-select": {
       "version": "2.2.6",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-select/-/react-select-2.2.6.tgz",
+      "integrity": "sha512-I30RydO+bnn2PQztvo25tswPH+wFBjehVGtmagkU78yMdwTwVf12wnAOF+AeP8S2N8xD+5UPbGhkUfPyvT+mwQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/number": "1.1.1",
@@ -3399,6 +3919,8 @@
     },
     "node_modules/@radix-ui/react-select/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -3415,6 +3937,8 @@
     },
     "node_modules/@radix-ui/react-separator": {
       "version": "1.1.7",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-separator/-/react-separator-1.1.7.tgz",
+      "integrity": "sha512-0HEb8R9E8A+jZjvmFCy/J4xhbXy3TV+9XSnGJ3KvTtjlIUy/YQ/p6UYZvi7YbeoeXdyU9+Y3scizK6hkY37baA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-primitive": "2.1.3"
@@ -3436,6 +3960,8 @@
     },
     "node_modules/@radix-ui/react-slider": {
       "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slider/-/react-slider-1.3.6.tgz",
+      "integrity": "sha512-JPYb1GuM1bxfjMRlNLE+BcmBC8onfCi60Blk7OBqi2MLTFdS+8401U4uFjnwkOr49BLmXxLC6JHkvAsx5OJvHw==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/number": "1.1.1",
@@ -3483,6 +4009,8 @@
     },
     "node_modules/@radix-ui/react-switch": {
       "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-switch/-/react-switch-1.2.6.tgz",
+      "integrity": "sha512-bByzr1+ep1zk4VubeEVViV592vu2lHE2BZY5OnzehZqOOgogN80+mNtCqPkhn2gklJqOpxWgPoYTSnhBCqpOXQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3538,6 +4066,8 @@
     },
     "node_modules/@radix-ui/react-toast": {
       "version": "1.2.15",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-toast/-/react-toast-1.2.15.tgz",
+      "integrity": "sha512-3OSz3TacUWy4WtOXV38DggwxoqJK4+eDkNMl5Z/MJZaoUPaP4/9lf81xXMe1I2ReTAptverZUpbPY4wWwWyL5g==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3593,6 +4123,8 @@
     },
     "node_modules/@radix-ui/react-toggle-group": {
       "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-toggle-group/-/react-toggle-group-1.1.11.tgz",
+      "integrity": "sha512-5umnS0T8JQzQT6HbPyO7Hh9dgd82NmS36DQr+X/YJ9ctFNCiiQd6IJAYYZ33LUwm8M+taCz5t2ui29fHZc4Y6Q==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3620,6 +4152,8 @@
     },
     "node_modules/@radix-ui/react-toolbar": {
       "version": "1.1.11",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-toolbar/-/react-toolbar-1.1.11.tgz",
+      "integrity": "sha512-4ol06/1bLoFu1nwUqzdD4Y5RZ9oDdKeiHIsntug54Hcr1pgaHiPqHFEaXI1IFP/EsOfROQZ8Mig9VTIRza6Tjg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3647,6 +4181,8 @@
     },
     "node_modules/@radix-ui/react-tooltip": {
       "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-tooltip/-/react-tooltip-1.2.8.tgz",
+      "integrity": "sha512-tY7sVt1yL9ozIxvmbtN5qtmH2krXcBCfjEiCgKGLqunJHvgvZG2Pcl2oQ3kbcZARb1BGEHdkLzcYGO8ynVlieg==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -3679,6 +4215,8 @@
     },
     "node_modules/@radix-ui/react-tooltip/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -3757,6 +4295,8 @@
     },
     "node_modules/@radix-ui/react-use-is-hydrated": {
       "version": "0.1.0",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-is-hydrated/-/react-use-is-hydrated-0.1.0.tgz",
+      "integrity": "sha512-U+UORVEq+cTnRIaostJv9AGdV3G6Y+zbVd+12e18jQ5A3c0xL03IhnHuiU4UV69wolOQp5GfR58NW/EgdQhwOA==",
       "license": "MIT",
       "dependencies": {
         "use-sync-external-store": "^1.5.0"
@@ -3786,6 +4326,8 @@
     },
     "node_modules/@radix-ui/react-use-previous": {
       "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-previous/-/react-use-previous-1.1.1.tgz",
+      "integrity": "sha512-2dHfToCj/pzca2Ck724OZ5L0EVrr3eHRNsG/b3xQJLA2hZpVCS99bLAX+hm1IHXDEnzU6by5z/5MIY794/a8NQ==",
       "license": "MIT",
       "peerDependencies": {
         "@types/react": "*",
@@ -3799,6 +4341,8 @@
     },
     "node_modules/@radix-ui/react-use-rect": {
       "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-rect/-/react-use-rect-1.1.1.tgz",
+      "integrity": "sha512-QTYuDesS0VtuHNNvMh+CjlKJ4LJickCMUAqjlE3+j8w+RlRpwyX3apEQKGFzbZGdo7XNG1tXa+bQqIE7HIXT2w==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/rect": "1.1.1"
@@ -3815,6 +4359,8 @@
     },
     "node_modules/@radix-ui/react-use-size": {
       "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-use-size/-/react-use-size-1.1.1.tgz",
+      "integrity": "sha512-ewrXRDTAqAXlkl6t/fkXWNAhFX9I+CkKlw6zjEwk86RSPKwZr3xpBRso655aqYafwtnbpHLj6toFzmd6xdVptQ==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-use-layout-effect": "1.1.1"
@@ -3831,6 +4377,8 @@
     },
     "node_modules/@radix-ui/react-visually-hidden": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-visually-hidden/-/react-visually-hidden-1.2.3.tgz",
+      "integrity": "sha512-pzJq12tEaaIhqjbzpCuv/OypJY/BPavOofm+dbab+MHLajy277+1lLm6JFcGgF5eskJ6mquGirhXY2GD/8u8Ug==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-primitive": "2.1.3"
@@ -3852,6 +4400,8 @@
     },
     "node_modules/@radix-ui/rect": {
       "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@radix-ui/rect/-/rect-1.1.1.tgz",
+      "integrity": "sha512-HPwpGIzkl28mWyZqG52jiqDJ12waP11Pa1lGoiyUkIEuMLBP0oeK/C89esbXrxsky5we7dfd8U58nm0SgAWpVw==",
       "license": "MIT"
     },
     "node_modules/@react-native-async-storage/async-storage": {
@@ -4094,16 +4644,45 @@
         }
       }
     },
+    "node_modules/@rollup/rollup-darwin-arm64": {
+      "version": "4.60.4",
+      "resolved": "https://registry.npmjs.org/@rollup/rollup-darwin-arm64/-/rollup-darwin-arm64-4.60.4.tgz",
+      "integrity": "sha512-tua0TaJxMOB1R0V0RS1jFZ/RpURFDJIOR2A6jWwQeawuFyS4gBW+rntLRaQd0EQ4bd6Vp44Z2rXW+YYDBsj6IA==",
+      "cpu": [
+        "arm64"
+      ],
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
     "node_modules/@rtsao/scc": {
       "version": "1.1.0",
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@s2-dev/streamstore": {
+      "version": "0.22.5",
+      "resolved": "https://registry.npmjs.org/@s2-dev/streamstore/-/streamstore-0.22.5.tgz",
+      "integrity": "sha512-GqdOKIbIoIxT+40fnKzHbrsHB6gBqKdECmFe7D3Ojk4FoN1Hu0LhFzZv6ZmVMjoHHU+55debS1xSWjZwQmbIyQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@protobuf-ts/runtime": "^2.11.1",
+        "debug": "^4.4.3"
+      }
+    },
     "node_modules/@sinclair/typebox": {
       "version": "0.27.10",
       "license": "MIT",
       "peer": true
     },
+    "node_modules/@socket.io/component-emitter": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@socket.io/component-emitter/-/component-emitter-3.1.2.tgz",
+      "integrity": "sha512-9BCxFwvbGg/RsZK9tjXd8s4UcwR0MWeFQ1XEKIQVVvAGJyINdrqKMcTRyLoK8Rse1GjzLV9cwjWV1olXRWEXVA==",
+      "license": "MIT"
+    },
     "node_modules/@solana-mobile/mobile-wallet-adapter-protocol": {
       "version": "2.2.8",
       "license": "Apache-2.0",
@@ -4805,22 +5384,407 @@
         "url": "https://github.com/sponsors/tannerlinsley"
       }
     },
-    "node_modules/@tybys/wasm-util": {
-      "version": "0.10.2",
+    "node_modules/@trigger.dev/build": {
+      "version": "4.4.6",
+      "resolved": "https://registry.npmjs.org/@trigger.dev/build/-/build-4.4.6.tgz",
+      "integrity": "sha512-eHPPaeuFe9GZDndQzP4QUlxocyIJWYSx0FMx1GEiAnEVKwXWUqiW72DRFH7cr9v7IQnI9YbAWRuWvyMPHSVLwg==",
       "dev": true,
       "license": "MIT",
-      "optional": true,
       "dependencies": {
-        "tslib": "^2.4.0"
+        "@prisma/config": "^6.10.0",
+        "@trigger.dev/core": "4.4.6",
+        "mlly": "^1.7.1",
+        "pkg-types": "^1.1.3",
+        "resolve": "^1.22.8",
+        "tinyglobby": "^0.2.2",
+        "tsconfck": "3.1.3"
+      },
+      "engines": {
+        "node": ">=18.20.0"
       }
     },
-    "node_modules/@types/connect": {
-      "version": "3.4.38",
-      "license": "MIT",
-      "peer": true,
+    "node_modules/@trigger.dev/build/node_modules/@prisma/config": {
+      "version": "6.19.3",
+      "resolved": "https://registry.npmjs.org/@prisma/config/-/config-6.19.3.tgz",
+      "integrity": "sha512-CBPT44BjlQxEt8kiMEauji2WHTDoVBOKl7UlewXmUgBPnr/oPRZC3psci5chJnYmH0ivEIog2OU9PGWoki3DLQ==",
+      "dev": true,
+      "license": "Apache-2.0",
       "dependencies": {
-        "@types/node": "*"
-      }
+        "c12": "3.1.0",
+        "deepmerge-ts": "7.1.5",
+        "effect": "3.21.0",
+        "empathic": "2.0.0"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/c12": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/c12/-/c12-3.1.0.tgz",
+      "integrity": "sha512-uWoS8OU1MEIsOv8p/5a82c3H31LsWVR5qiyXVfBNOzfffjUWtPnhAb4BYI2uG2HfGmZmFjCtui5XNWaps+iFuw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chokidar": "^4.0.3",
+        "confbox": "^0.2.2",
+        "defu": "^6.1.4",
+        "dotenv": "^16.6.1",
+        "exsolve": "^1.0.7",
+        "giget": "^2.0.0",
+        "jiti": "^2.4.2",
+        "ohash": "^2.0.11",
+        "pathe": "^2.0.3",
+        "perfect-debounce": "^1.0.0",
+        "pkg-types": "^2.2.0",
+        "rc9": "^2.1.2"
+      },
+      "peerDependencies": {
+        "magicast": "^0.3.5"
+      },
+      "peerDependenciesMeta": {
+        "magicast": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/c12/node_modules/pkg-types": {
+      "version": "2.3.1",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-2.3.1.tgz",
+      "integrity": "sha512-y+ichcgc2LrADuhLNAx8DFjVfgz91pRxfZdI3UDhxHvcVEZsenLO+7XaU5vOp0u/7V/wZ+plyuQxtrDlZJ+yeg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.2.4",
+        "exsolve": "^1.0.8",
+        "pathe": "^2.0.3"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/dotenv": {
+      "version": "16.6.1",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",
+      "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/effect": {
+      "version": "3.21.0",
+      "resolved": "https://registry.npmjs.org/effect/-/effect-3.21.0.tgz",
+      "integrity": "sha512-PPN80qRokCd1f015IANNhrwOnLO7GrrMQfk4/lnZRE/8j7UPWrNNjPV0uBrZutI/nHzernbW+J0hdqQysHiSnQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@standard-schema/spec": "^1.0.0",
+        "fast-check": "^3.23.1"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/giget": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/giget/-/giget-2.0.0.tgz",
+      "integrity": "sha512-L5bGsVkxJbJgdnwyuheIunkGatUF/zssUoxxjACCseZYAVbaqdh9Tsmmlkl8vYan09H7sbvKt4pS8GqKLBrEzA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "citty": "^0.1.6",
+        "consola": "^3.4.0",
+        "defu": "^6.1.4",
+        "node-fetch-native": "^1.6.6",
+        "nypm": "^0.6.0",
+        "pathe": "^2.0.3"
+      },
+      "bin": {
+        "giget": "dist/cli.mjs"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/perfect-debounce": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/perfect-debounce/-/perfect-debounce-1.0.0.tgz",
+      "integrity": "sha512-xCy9V055GLEqoFaHoC1SoLIaLmWctgCUaBaWxDZ7/Zx4CTyX7cJQLJOok/orfjZAh9kEYpjJa4d0KcJmCbctZA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@trigger.dev/build/node_modules/pkg-types": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
+      "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.1.8",
+        "mlly": "^1.7.4",
+        "pathe": "^2.0.1"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/pkg-types/node_modules/confbox": {
+      "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
+      "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@trigger.dev/build/node_modules/rc9": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/rc9/-/rc9-2.1.2.tgz",
+      "integrity": "sha512-btXCnMmRIBINM2LDZoEmOogIZU7Qe7zn4BpomSKZ/ykbLObuBdvG+mFq11DL6fjH1DRwHhrlgtYWG96bJiC7Cg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "defu": "^6.1.4",
+        "destr": "^2.0.3"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/@trigger.dev/build/node_modules/resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/@trigger.dev/core": {
+      "version": "4.4.6",
+      "resolved": "https://registry.npmjs.org/@trigger.dev/core/-/core-4.4.6.tgz",
+      "integrity": "sha512-oXAjxBNVMiKXUKj1EnHUlO2ULujc4Dy8ad+H/59DYZGY1barkGVzrQAQIpBZo/kDygu7dKGT+F5yBkbIkYjAUw==",
+      "license": "MIT",
+      "dependencies": {
+        "@bugsnag/cuid": "^3.1.1",
+        "@electric-sql/client": "1.0.14",
+        "@google-cloud/precise-date": "^4.0.0",
+        "@jsonhero/path": "^1.0.21",
+        "@opentelemetry/api": "1.9.0",
+        "@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.22.5",
+        "dequal": "^2.0.3",
+        "eventsource": "^3.0.5",
+        "eventsource-parser": "^3.0.0",
+        "execa": "^8.0.1",
+        "humanize-duration": "^3.27.3",
+        "jose": "^5.4.0",
+        "nanoid": "3.3.8",
+        "prom-client": "^15.1.0",
+        "socket.io": "4.7.4",
+        "socket.io-client": "4.7.5",
+        "std-env": "^3.8.1",
+        "tinyexec": "^0.3.2",
+        "uncrypto": "^0.1.3",
+        "zod": "3.25.76",
+        "zod-error": "1.5.0",
+        "zod-validation-error": "^1.5.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      }
+    },
+    "node_modules/@trigger.dev/core/node_modules/nanoid": {
+      "version": "3.3.8",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.8.tgz",
+      "integrity": "sha512-WNLf5Sd8oZxOm+TzppcYk8gVOgP+l58xNy58D0nbUnOxOWRWvlcCV4kUF7ltmI6PsrLl/BgKEyS4mqsGChFN0w==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/@trigger.dev/core/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/@trigger.dev/core/node_modules/zod-validation-error": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/zod-validation-error/-/zod-validation-error-1.5.0.tgz",
+      "integrity": "sha512-/7eFkAI4qV0tcxMBB/3+d2c1P6jzzZYdYSlBuAklzMuCrJu5bzJfHS0yVAS87dRHVlhftd6RFJDIvv03JgkSbw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.0.0"
+      },
+      "peerDependencies": {
+        "zod": "^3.18.0"
+      }
+    },
+    "node_modules/@trigger.dev/react-hooks": {
+      "version": "4.4.6",
+      "resolved": "https://registry.npmjs.org/@trigger.dev/react-hooks/-/react-hooks-4.4.6.tgz",
+      "integrity": "sha512-Fr4nQIt3sAAPGTbBJfALHzMQUE0O4HPNVz4lRwIwCc3/HAfjPr8uza6e7iagDOWWs68PWtOOayDWQ5Nvbz6QOg==",
+      "license": "MIT",
+      "dependencies": {
+        "@trigger.dev/core": "^4.4.6",
+        "swr": "^2.2.5"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      },
+      "peerDependencies": {
+        "react": "^18.0 || ^19.0 || ^19.0.0-rc",
+        "react-dom": "^18.0 || ^19.0 || ^19.0.0-rc"
+      }
+    },
+    "node_modules/@trigger.dev/sdk": {
+      "version": "4.4.6",
+      "resolved": "https://registry.npmjs.org/@trigger.dev/sdk/-/sdk-4.4.6.tgz",
+      "integrity": "sha512-FAC5/oES4dClLWlLGvnuNUlhfzWXDA6ResxB7B6/2UohSdxn3yWt9uOtjEL434JiN0xNUCiSAN8KTP1azpOgBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@opentelemetry/api": "1.9.0",
+        "@opentelemetry/semantic-conventions": "1.36.0",
+        "@trigger.dev/core": "4.4.6",
+        "chalk": "^5.2.0",
+        "cronstrue": "^2.21.0",
+        "debug": "^4.3.4",
+        "evt": "^2.4.13",
+        "slug": "^6.0.0",
+        "ulid": "^2.3.0",
+        "uncrypto": "^0.1.3",
+        "ws": "^8.11.0"
+      },
+      "engines": {
+        "node": ">=18.20.0"
+      },
+      "peerDependencies": {
+        "ai": "^4.2.0 || ^5.0.0 || ^6.0.0",
+        "zod": "^3.0.0 || ^4.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ai": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@trigger.dev/sdk/node_modules/chalk": {
+      "version": "5.6.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+      "integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.17.0 || ^14.13 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
+      }
+    },
+    "node_modules/@trigger.dev/sdk/node_modules/ws": {
+      "version": "8.21.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",
+      "integrity": "sha512-Vsp28b7DRcimFQvrqu2Wek3z1iYxDCWqHYB8Qsnk/S4RfaCQzPGPyBNuVjJV3cd6UiKtUtp6sNM77gWvzcCH+g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.2",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@types/connect": {
+      "version": "3.4.38",
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/node": "*"
+      }
+    },
+    "node_modules/@types/cookie": {
+      "version": "0.4.1",
+      "resolved": "https://registry.npmjs.org/@types/cookie/-/cookie-0.4.1.tgz",
+      "integrity": "sha512-XW/Aa8APYr6jSVVA1y/DEIZX0/GMKLEVekNG727R8cs56ahETkRAy/3DR7+fJyh7oUgGwNQaRfXCun0+KbWY7Q==",
+      "license": "MIT"
+    },
+    "node_modules/@types/cors": {
+      "version": "2.8.19",
+      "resolved": "https://registry.npmjs.org/@types/cors/-/cors-2.8.19.tgz",
+      "integrity": "sha512-mFNylyeyqN93lfe/9CSxOGREz8cpzAhH+E93xJ4xWQf62V8sQ/24reV2nyzUWM6H6Xji+GGHpkbLe7pVoUEskg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/node": "*"
+      }
     },
     "node_modules/@types/d3-color": {
       "version": "3.1.3",
@@ -4859,11 +5823,37 @@
         "@types/d3-selection": "*"
       }
     },
+    "node_modules/@types/debug": {
+      "version": "4.1.13",
+      "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.13.tgz",
+      "integrity": "sha512-KSVgmQmzMwPlmtljOomayoR89W4FynCAi3E8PPs7vmDVPe84hT+vGPKkJfThkmXs0x0jAaa9U8uW8bbfyS2fWw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/ms": "*"
+      }
+    },
     "node_modules/@types/estree": {
       "version": "1.0.9",
-      "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/estree-jsx": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/@types/estree-jsx/-/estree-jsx-1.0.5.tgz",
+      "integrity": "sha512-52CcUVNFyfb1A2ALocQw/Dd1BQFNmSdkuC3BkZ6iqhdMfQz7JWOFRuJFloOzjk+6WijU56m9oKXFAXc7o3Towg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "*"
+      }
+    },
+    "node_modules/@types/hast": {
+      "version": "3.0.4",
+      "resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",
+      "integrity": "sha512-WPs+bbQw5aCj+x6laNGWLH3wviHtoCv/P3+otBhbOhJgG8qtpdAMlTCxLtsTWA7LH1Oh/bFCHsBn0TPS5m30EQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
     "node_modules/@types/istanbul-lib-coverage": {
       "version": "2.0.6",
       "license": "MIT",
@@ -4894,6 +5884,21 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/@types/mdast": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/@types/mdast/-/mdast-4.0.4.tgz",
+      "integrity": "sha512-kGaNbPh1k7AFzgpud/gMdvIm5xuECykRR+JnWKQno9TAXVa6WIVCGTPvYGekIDL4uwCZQSYbUxNBSb1aUo79oA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "*"
+      }
+    },
+    "node_modules/@types/ms": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/@types/ms/-/ms-2.1.0.tgz",
+      "integrity": "sha512-GsCCIZDE/p3i96vtEqx+7dBUGXrc7zeSK3wwPHIaRThS+9OhWIXRqzs4d6k1SVU8g91DrNRWxWUGhp5KXQb2VA==",
+      "license": "MIT"
+    },
     "node_modules/@types/node": {
       "version": "20.19.41",
       "license": "MIT",
@@ -4929,6 +5934,12 @@
         "@types/react": "^19.2.0"
       }
     },
+    "node_modules/@types/unist": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-3.0.3.tgz",
+      "integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==",
+      "license": "MIT"
+    },
     "node_modules/@types/ws": {
       "version": "7.4.7",
       "license": "MIT",
@@ -5213,6 +6224,12 @@
         "url": "https://opencollective.com/eslint"
       }
     },
+    "node_modules/@ungap/structured-clone": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/@ungap/structured-clone/-/structured-clone-1.3.1.tgz",
+      "integrity": "sha512-mUFwbeTqrVgDQxFveS+df2yfap6iuP20NAKAsBt5jDEoOTDew+zwLAOilHCeQJOVSvmgCX4ogqIrA0mnyr08yQ==",
+      "license": "ISC"
+    },
     "node_modules/@unrs/resolver-binding-android-arm-eabi": {
       "version": "1.12.2",
       "resolved": "https://registry.npmjs.org/@unrs/resolver-binding-android-arm-eabi/-/resolver-binding-android-arm-eabi-1.12.2.tgz",
@@ -5570,6 +6587,15 @@
         "node": ">=20.0.0"
       }
     },
+    "node_modules/@vercel/oidc": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/@vercel/oidc/-/oidc-3.2.0.tgz",
+      "integrity": "sha512-UycprH3T6n3jH0k44NHMa7pnFHGu/N05MjojYr+Mc6I7obkoLIJujSWwin1pCvdy/eOxrI/l3uDLQsmcrOb4ug==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">= 20"
+      }
+    },
     "node_modules/@wallet-standard/app": {
       "version": "1.1.0",
       "license": "Apache-2.0",
@@ -5713,6 +6739,15 @@
         "node": ">=0.4.0"
       }
     },
+    "node_modules/acorn-import-attributes": {
+      "version": "1.9.5",
+      "resolved": "https://registry.npmjs.org/acorn-import-attributes/-/acorn-import-attributes-1.9.5.tgz",
+      "integrity": "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ==",
+      "license": "MIT",
+      "peerDependencies": {
+        "acorn": "^8"
+      }
+    },
     "node_modules/acorn-jsx": {
       "version": "5.3.2",
       "dev": true,
@@ -5740,10 +6775,28 @@
         "node": ">= 8.0.0"
       }
     },
-    "node_modules/ajv": {
-      "version": "6.15.0",
-      "dev": true,
-      "license": "MIT",
+    "node_modules/ai": {
+      "version": "6.0.193",
+      "resolved": "https://registry.npmjs.org/ai/-/ai-6.0.193.tgz",
+      "integrity": "sha512-VQOTOse8+X8kMtg61DNSXlYJzwOW4NjMLDJNk/qxClWsFe4oiyFJDHGGG1oezfGcFzuYuQe/8Z7r4kwiZWh2YQ==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@ai-sdk/gateway": "3.0.121",
+        "@ai-sdk/provider": "3.0.10",
+        "@ai-sdk/provider-utils": "4.0.27",
+        "@opentelemetry/api": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "zod": "^3.25.76 || ^4.1.8"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "6.15.0",
+      "dev": true,
+      "license": "MIT",
       "dependencies": {
         "fast-deep-equal": "^3.1.1",
         "fast-json-stable-stringify": "^2.0.0",
@@ -6073,6 +7126,16 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/bail": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/bail/-/bail-2.0.2.tgz",
+      "integrity": "sha512-0xO6mYd7JB2YesxDKplafRpsiOzPt9V02ddPCLbY1xYGPOX24NTyN50qnUxgCPcSoYMhKpAuBTjQoRZCAkUDRw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/balanced-match": {
       "version": "1.0.2",
       "dev": true,
@@ -6103,6 +7166,15 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/base64id": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/base64id/-/base64id-2.0.0.tgz",
+      "integrity": "sha512-lGe34o6EHj9y3Kts9R4ZYs/Gr+6N7MCaMlIFA3F1R2O5/m7K06AxfSeO5530PEERE6/WyEg3lsuyw4GHlPZHog==",
+      "license": "MIT",
+      "engines": {
+        "node": "^4.5.0 || >= 5.9"
+      }
+    },
     "node_modules/baseline-browser-mapping": {
       "version": "2.10.31",
       "license": "Apache-2.0",
@@ -6117,6 +7189,12 @@
       "version": "2.9.2",
       "license": "MIT"
     },
+    "node_modules/bintrees": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/bintrees/-/bintrees-1.0.2.tgz",
+      "integrity": "sha512-VOMgTMwjAaUG580SXn3LacVgjurrbMme7ZZNYGSSV7mmtY6QQRh0Eg3pwIcntQ77DErK1L0NxkbetjcoXzVwKw==",
+      "license": "MIT"
+    },
     "node_modules/bn.js": {
       "version": "5.2.3",
       "license": "MIT",
@@ -6358,6 +7436,16 @@
       ],
       "license": "CC-BY-4.0"
     },
+    "node_modules/ccount": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/ccount/-/ccount-2.0.1.tgz",
+      "integrity": "sha512-eyrF0jiFpY+3drT6383f1qhkbGsLSifNAjA61IUjZjmLCWjItY6LB9ft9YhoDgwfmclB2zhu51Lc7+95b8NRAg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chalk": {
       "version": "4.1.2",
       "license": "MIT",
@@ -6372,6 +7460,46 @@
         "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
+    "node_modules/character-entities": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/character-entities/-/character-entities-2.0.2.tgz",
+      "integrity": "sha512-shx7oQ0Awen/BRIdkjkvz54PnEEI/EjwXDSIZp86/KKdbafHh1Df/RYGBhn4hbe2+uKC9FnT5UCEdyPz3ai9hQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-html4": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/character-entities-html4/-/character-entities-html4-2.1.0.tgz",
+      "integrity": "sha512-1v7fgQRj6hnSwFpq1Eu0ynr/CDEw0rXo2B61qXrLNdHZmPKgb7fqS1a2JwF0rISo9q77jDI8VMEHoApn8qDoZA==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-entities-legacy": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/character-entities-legacy/-/character-entities-legacy-3.0.0.tgz",
+      "integrity": "sha512-RpPp0asT/6ufRm//AJVwpViZbGM/MkjQFxJccQRHmISF/22NBtsHqAWmL+/pmkPWoIUJdWyeVleTl1wydHATVQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/character-reference-invalid": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/character-reference-invalid/-/character-reference-invalid-2.0.1.tgz",
+      "integrity": "sha512-iBZ4F4wRbyORVsu0jPV7gXkOsGYjGHPmAyv+HiHG8gi5PtC9KI2j1+v8/tlibRvjoWX027ypmG/n0HtO5t7unw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/chart.js": {
       "version": "4.5.1",
       "license": "MIT",
@@ -6429,6 +7557,22 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/citty": {
+      "version": "0.1.6",
+      "resolved": "https://registry.npmjs.org/citty/-/citty-0.1.6.tgz",
+      "integrity": "sha512-tskPPKEs8D2KPafUypv2gxwJP8h/OaJmC82QQGGDQcHvXX43xF2VDACcJVmZ0EuSxkpO9Kc4MlrA3q0+FG58AQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "consola": "^3.2.3"
+      }
+    },
+    "node_modules/cjs-module-lexer": {
+      "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-1.4.3.tgz",
+      "integrity": "sha512-9z8TZaGM1pfswYeXrUpzPrkx8UnWYdhJclsiYMm6x/w5+nN+8Tf/LnAgfLGQCm59qAOxU8WwHEq2vNwF6i4j+Q==",
+      "license": "MIT"
+    },
     "node_modules/class-variance-authority": {
       "version": "0.7.1",
       "license": "Apache-2.0",
@@ -6468,6 +7612,16 @@
       "version": "1.1.4",
       "license": "MIT"
     },
+    "node_modules/comma-separated-tokens": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
+      "integrity": "sha512-Fu4hJdvzeylCfQPp9SGWidpzrMs7tTrlu6Vb8XGaRGck8QSNZJJp538Wrb60Lax4fPwR64ViY468OIUTbRlGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/commander": {
       "version": "14.0.3",
       "resolved": "https://registry.npmjs.org/commander/-/commander-14.0.3.tgz",
@@ -6479,6 +7633,8 @@
     },
     "node_modules/compute-scroll-into-view": {
       "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/compute-scroll-into-view/-/compute-scroll-into-view-3.1.1.tgz",
+      "integrity": "sha512-VRhuHOLoKYOy4UbilLbUzbYg93XLjv2PncJC50EuTWPA3gaja1UjBsUP/D/9/juV3vQFr6XBEzn9KCAHdUvOHw==",
       "license": "MIT"
     },
     "node_modules/concat-map": {
@@ -6517,10 +7673,29 @@
       "license": "MIT",
       "peer": true
     },
+    "node_modules/consola": {
+      "version": "3.4.2",
+      "resolved": "https://registry.npmjs.org/consola/-/consola-3.4.2.tgz",
+      "integrity": "sha512-5IKcdX0nnYavi6G7TtOhwkYzyjfJlatbjMjuLSfE2kYT5pMDOilZ4OvMhi637CcDICTmz3wARPoyhqyX1Y+XvA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^14.18.0 || >=16.10.0"
+      }
+    },
     "node_modules/convert-source-map": {
       "version": "2.0.0",
       "license": "MIT"
     },
+    "node_modules/cookie": {
+      "version": "0.4.2",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.4.2.tgz",
+      "integrity": "sha512-aSWTXFzaKWkvHO1Ny/s+ePFpvKsPnjc551iI41v3ny/ow6tBG5Vd+FuqGNhh1LxOmVzOlGUriIlOaokOvhaStA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
     "node_modules/copy-to-clipboard": {
       "version": "3.3.3",
       "license": "MIT",
@@ -6537,6 +7712,23 @@
         "url": "https://opencollective.com/core-js"
       }
     },
+    "node_modules/cors": {
+      "version": "2.8.6",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.6.tgz",
+      "integrity": "sha512-tJtZBBHA6vjIAaF6EnIaq6laBBP9aq/Y3ouVJjEfoHbRBcHBAHYcMh/w8LDrk2PvIMMq8gmopa5D4V8RmbrxGw==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
     "node_modules/cosmiconfig": {
       "version": "7.1.0",
       "license": "MIT",
@@ -6551,6 +7743,15 @@
         "node": ">=10"
       }
     },
+    "node_modules/cronstrue": {
+      "version": "2.59.0",
+      "resolved": "https://registry.npmjs.org/cronstrue/-/cronstrue-2.59.0.tgz",
+      "integrity": "sha512-YKGmAy84hKH+hHIIER07VCAHf9u0Ldelx1uU6EBxsRPDXIA1m5fsKmJfyC3xBhw6cVC/1i83VdbL4PvepTrt8A==",
+      "license": "MIT",
+      "bin": {
+        "cronstrue": "bin/cli.js"
+      }
+    },
     "node_modules/cross-spawn": {
       "version": "7.0.6",
       "license": "MIT",
@@ -6729,6 +7930,19 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/decode-named-character-reference": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/decode-named-character-reference/-/decode-named-character-reference-1.3.0.tgz",
+      "integrity": "sha512-GtpQYB283KrPp6nRw50q3U9/VfOutZOe103qlN7BPP6Ad27xYnOIWv4lPzo8HCAL+mMZofJ9KEy30fq6MfaK6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/deep-is": {
       "version": "0.1.4",
       "dev": true,
@@ -6835,12 +8049,27 @@
       "version": "1.1.0",
       "license": "MIT"
     },
+    "node_modules/devlop": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",
+      "integrity": "sha512-RWmIqhcFf1lRYBvNmr7qTNuyCt/7/ns2jbpp1+PalgE/rDQcBT0fioSMUpJ93irlUhC5hrg4cYqe6U+0ImW0rA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/dijkstrajs": {
       "version": "1.0.3",
       "license": "MIT"
     },
     "node_modules/direction": {
       "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/direction/-/direction-1.0.4.tgz",
+      "integrity": "sha512-GYqKi1aH7PJXxdhTeZBFrg8vUBeKXi+cNprXsC1kpJcbcVnV9wBsrOu1cQEdG0WeQwlfHiy3XvnKfIrJ2R0NzQ==",
       "license": "MIT",
       "bin": {
         "direction": "cli.js"
@@ -6913,6 +8142,168 @@
         "node": ">=14"
       }
     },
+    "node_modules/engine.io": {
+      "version": "6.5.5",
+      "resolved": "https://registry.npmjs.org/engine.io/-/engine.io-6.5.5.tgz",
+      "integrity": "sha512-C5Pn8Wk+1vKBoHghJODM63yk8MvrO9EWZUfkAt5HAqIgPE4/8FF0PEGHXtEd40l223+cE5ABWuPzm38PHFXfMA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/cookie": "^0.4.1",
+        "@types/cors": "^2.8.12",
+        "@types/node": ">=10.0.0",
+        "accepts": "~1.3.4",
+        "base64id": "2.0.0",
+        "cookie": "~0.4.1",
+        "cors": "~2.8.5",
+        "debug": "~4.3.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.17.1"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/engine.io-client": {
+      "version": "6.5.4",
+      "resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-6.5.4.tgz",
+      "integrity": "sha512-GeZeeRjpD2qf49cZQ0Wvh/8NJNfeXkXXcoGh+F77oEAgo9gUHwT1fCRxSNU+YEEaysOJTnsFHmM5oAcPy4ntvQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.3.1",
+        "engine.io-parser": "~5.2.1",
+        "ws": "~8.17.1",
+        "xmlhttprequest-ssl": "~2.0.0"
+      }
+    },
+    "node_modules/engine.io-client/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/engine.io-client/node_modules/ws": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/engine.io-parser": {
+      "version": "5.2.3",
+      "resolved": "https://registry.npmjs.org/engine.io-parser/-/engine.io-parser-5.2.3.tgz",
+      "integrity": "sha512-HqD3yTBfnBxIrbnM1DoD6Pcq8NECnh8d4As1Qgh0z5Gg3jRRIqijury0CL3ghu/edArpUYiYqQiDUQBIs4np3Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/engine.io/node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/engine.io/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/engine.io/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/engine.io/node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/engine.io/node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/engine.io/node_modules/ws": {
+      "version": "8.17.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.17.1.tgz",
+      "integrity": "sha512-6XQFvXTkbfUOZOKKILFG1PDK2NDQs4azKQl26T0YS5CxqWLgXajbPZ+h4gZekJyRqFU8pvnbAbbs/3TgRPy+GQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/enhanced-resolve": {
       "version": "5.21.6",
       "dev": true,
@@ -7542,6 +8933,16 @@
         "node": ">=4.0"
       }
     },
+    "node_modules/estree-util-is-identifier-name": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/estree-util-is-identifier-name/-/estree-util-is-identifier-name-3.0.0.tgz",
+      "integrity": "sha512-hFtqIDZTIUZ9BXLb8y4pYGyk6+wekIivNVTcmvk8NoOh+VeRn5y6cEHzbURrWbfp1fIqdVipilzj+lfaadNZmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/esutils": {
       "version": "2.0.3",
       "dev": true,
@@ -7570,6 +8971,61 @@
       "version": "5.0.4",
       "license": "MIT"
     },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.0.tgz",
+      "integrity": "sha512-kJezFj9YFAMLeORyi7aCLxLbD5/qWMQnoMVlVPyHIll7lgRJCc3JVln9Vgl9nwQi0YkMnhdGTMNn7CkRRAptMg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/evt": {
+      "version": "2.5.9",
+      "resolved": "https://registry.npmjs.org/evt/-/evt-2.5.9.tgz",
+      "integrity": "sha512-GpjX476FSlttEGWHT8BdVMoI8wGXQGbEOtKcP4E+kggg+yJzXBZN2n4x7TS/zPBJ1DZqWI+rguZZApjjzQ0HpA==",
+      "license": "MIT",
+      "dependencies": {
+        "minimal-polyfills": "^2.2.3",
+        "run-exclusive": "^2.2.19",
+        "tsafe": "^1.8.5"
+      }
+    },
+    "node_modules/execa": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/execa/-/execa-8.0.1.tgz",
+      "integrity": "sha512-VyhnebXciFV2DESc+p6B+y0LjSm0krU4OgJN44qFAhBY0TJ+1V61tYD2+wHusZ6F9n5K+vl8k0sTy7PEfV4qpg==",
+      "license": "MIT",
+      "dependencies": {
+        "cross-spawn": "^7.0.3",
+        "get-stream": "^8.0.1",
+        "human-signals": "^5.0.0",
+        "is-stream": "^3.0.0",
+        "merge-stream": "^2.0.0",
+        "npm-run-path": "^5.1.0",
+        "onetime": "^6.0.0",
+        "signal-exit": "^4.1.0",
+        "strip-final-newline": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=16.17"
+      },
+      "funding": {
+        "url": "https://github.com/sindresorhus/execa?sponsor=1"
+      }
+    },
     "node_modules/exponential-backoff": {
       "version": "3.1.3",
       "license": "Apache-2.0",
@@ -7579,6 +9035,12 @@
       "version": "1.0.8",
       "license": "MIT"
     },
+    "node_modules/extend": {
+      "version": "3.0.2",
+      "resolved": "https://registry.npmjs.org/extend/-/extend-3.0.2.tgz",
+      "integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==",
+      "license": "MIT"
+    },
     "node_modules/eyes": {
       "version": "0.1.8",
       "peer": true,
@@ -7834,6 +9296,8 @@
     },
     "node_modules/frimousse": {
       "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/frimousse/-/frimousse-0.2.0.tgz",
+      "integrity": "sha512-viSrsVQWKR4Q7xzC0lkx3Wu9i1+IHrth0QXn0nlIIJXpltwUnjkGXSTuoW7WHI5aJ4z49WR8E/pyQizFjlNtTA==",
       "license": "MIT",
       "workspaces": [
         ".",
@@ -7963,6 +9427,18 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/get-stream": {
+      "version": "8.0.1",
+      "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-8.0.1.tgz",
+      "integrity": "sha512-VaUJspBffn/LMCJVoMvSAdmscJyS1auj5Zulnn5UoYcY531UWmdwhRWkcGKnGU93m5HSXP9LP2usOryrBtQowA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/get-symbol-description": {
       "version": "1.1.0",
       "dev": true,
@@ -8128,6 +9604,46 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/hast-util-to-jsx-runtime": {
+      "version": "2.3.6",
+      "resolved": "https://registry.npmjs.org/hast-util-to-jsx-runtime/-/hast-util-to-jsx-runtime-2.3.6.tgz",
+      "integrity": "sha512-zl6s8LwNyo1P9uw+XJGvZtdFF1GdAkOg8ujOw+4Pyb76874fLps4ueHXDhXWdk6YHQ6OgUtinliG7RsYvCbbBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/unist": "^3.0.0",
+        "comma-separated-tokens": "^2.0.0",
+        "devlop": "^1.0.0",
+        "estree-util-is-identifier-name": "^3.0.0",
+        "hast-util-whitespace": "^3.0.0",
+        "mdast-util-mdx-expression": "^2.0.0",
+        "mdast-util-mdx-jsx": "^3.0.0",
+        "mdast-util-mdxjs-esm": "^2.0.0",
+        "property-information": "^7.0.0",
+        "space-separated-tokens": "^2.0.0",
+        "style-to-js": "^1.0.0",
+        "unist-util-position": "^5.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/hast-util-whitespace": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/hast-util-whitespace/-/hast-util-whitespace-3.0.0.tgz",
+      "integrity": "sha512-88JUN06ipLwsnv+dVn+OIYOvAuvBMy/Qoi6O7mQHxdPXpjy+Cd6xRkWwux7DKO+4sYILtLBRIKgsdpS2gQc7qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/hermes-compiler": {
       "version": "250829098.0.10",
       "license": "MIT",
@@ -8160,6 +9676,16 @@
         "node": ">=16.9.0"
       }
     },
+    "node_modules/html-url-attributes": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/html-url-attributes/-/html-url-attributes-3.0.1.tgz",
+      "integrity": "sha512-ol6UPyBWqsrO6EJySPz2O7ZSr856WDrEzM5zMqp+FJJLGMW35cLYmmZnl0vztAZxRUoNZJFTCohfjuIJ8I4QBQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/http-errors": {
       "version": "2.0.1",
       "license": "MIT",
@@ -8203,6 +9729,24 @@
         "node": ">= 14"
       }
     },
+    "node_modules/human-signals": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/human-signals/-/human-signals-5.0.0.tgz",
+      "integrity": "sha512-AXcZb6vzzrFAUE61HnN4mpLqd/cSIwNQjtNWR0euPm6y0iqx3G4gOXaIDdtdDwZmhwe82LA6+zinmW4UBWVePQ==",
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=16.17.0"
+      }
+    },
+    "node_modules/humanize-duration": {
+      "version": "3.33.2",
+      "resolved": "https://registry.npmjs.org/humanize-duration/-/humanize-duration-3.33.2.tgz",
+      "integrity": "sha512-K7Ny/ULO1hDm2nnhvAY+SJV1skxFb61fd073SG1IWJl+D44ULrruCuTyjHKjBVVcSuTlnY99DKtgEG39CM5QOQ==",
+      "license": "Unlicense",
+      "funding": {
+        "url": "https://github.com/sponsors/EvanHahn"
+      }
+    },
     "node_modules/humanize-ms": {
       "version": "1.2.1",
       "license": "MIT",
@@ -8288,6 +9832,18 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/import-in-the-middle": {
+      "version": "1.15.0",
+      "resolved": "https://registry.npmjs.org/import-in-the-middle/-/import-in-the-middle-1.15.0.tgz",
+      "integrity": "sha512-bpQy+CrsRmYmoPMAE/0G33iwRqwW4ouqdRg8jgbH3aKuCtOc8lxgmYXg2dMM92CRiGP660EtBcymH/eVUpCSaA==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "acorn": "^8.14.0",
+        "acorn-import-attributes": "^1.9.5",
+        "cjs-module-lexer": "^1.2.2",
+        "module-details-from-path": "^1.0.3"
+      }
+    },
     "node_modules/imurmurhash": {
       "version": "0.1.4",
       "dev": true,
@@ -8301,6 +9857,12 @@
       "license": "ISC",
       "peer": true
     },
+    "node_modules/inline-style-parser": {
+      "version": "0.2.7",
+      "resolved": "https://registry.npmjs.org/inline-style-parser/-/inline-style-parser-0.2.7.tgz",
+      "integrity": "sha512-Nb2ctOyNR8DqQoR0OwRG95uNWIC0C1lCgf5Naz5H6Ji72KZ8OcFZLz2P5sNgwlyoJ8Yif11oMuYs5pBQa86csA==",
+      "license": "MIT"
+    },
     "node_modules/input-otp": {
       "version": "1.4.2",
       "license": "MIT",
@@ -8330,6 +9892,30 @@
         "loose-envify": "^1.0.0"
       }
     },
+    "node_modules/is-alphabetical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphabetical/-/is-alphabetical-2.0.1.tgz",
+      "integrity": "sha512-FWyyY60MeTNyeSRpkM2Iry0G9hpr7/9kD40mD/cGQEuilcZYS4okz8SN2Q6rLCJ8gbCt6fN+rC+6tMGS99LaxQ==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/is-alphanumerical": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-alphanumerical/-/is-alphanumerical-2.0.1.tgz",
+      "integrity": "sha512-hmbYhX/9MUMF5uh7tOXyK/n0ZvWpad5caBA17GsC6vyuCqaWliRG5K1qS9inmUhEMaOBIW7/whAnSwveW/LtZw==",
+      "license": "MIT",
+      "dependencies": {
+        "is-alphabetical": "^2.0.0",
+        "is-decimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-array-buffer": {
       "version": "3.0.5",
       "dev": true,
@@ -8494,6 +10080,16 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-decimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-decimal/-/is-decimal-2.0.1.tgz",
+      "integrity": "sha512-AAB9hiomQs5DXWcRB1rqsxGUstbRroFOPPVAomNk/3XHR5JyEZChOyTWe2oayKnsSsr/kcGqF+z6yuH6HHpN0A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-docker": {
       "version": "2.2.1",
       "license": "MIT",
@@ -8566,8 +10162,20 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/is-hexadecimal": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/is-hexadecimal/-/is-hexadecimal-2.0.1.tgz",
+      "integrity": "sha512-DgZQp241c8oO6cA1SbTEWiXeoxV42vlcJxgH+B3hi1AiqqKruZR3ZGF8In3fj4+/y/7rHvlOZLZtgJ/4ttYGZg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/is-hotkey": {
       "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/is-hotkey/-/is-hotkey-0.2.0.tgz",
+      "integrity": "sha512-UknnZK4RakDmTgz4PI1wIph5yxSs/mvChWs9ifnlXsKuXgWmOkY/hAE0H/k2MIqH0RlRye0i1oC07MCRSD28Mw==",
       "license": "MIT"
     },
     "node_modules/is-map": {
@@ -8630,6 +10238,8 @@
     },
     "node_modules/is-plain-object": {
       "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.0.0.tgz",
+      "integrity": "sha512-VRSzKkbMm5jMDoKLbltAkFQ5Qr7VDiTFGXxYFXXowVj387GeGNOCsOH6Msy00SGZ3Fp84b1Naa1psqgcCIEP5Q==",
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -8681,6 +10291,18 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/is-stream": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/is-stream/-/is-stream-3.0.0.tgz",
+      "integrity": "sha512-LnQR4bZ9IADDRSkvpqMGvt/tEJWclzklNgSw48V5EAaAeDd6qGvN8ei6k5p0tvxSR171VmGyHuTiAOfxAbr8kA==",
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/is-string": {
       "version": "1.1.1",
       "dev": true,
@@ -8956,6 +10578,15 @@
         "jiti": "lib/jiti-cli.mjs"
       }
     },
+    "node_modules/jose": {
+      "version": "5.10.0",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-5.10.0.tgz",
+      "integrity": "sha512-s+3Al/p9g32Iq+oqXxkW//7jk2Vig6FF1CFqzVXoTUXt2qz89YWbL+OwS17NFYEvxC35n0FKeGO2LGYSxeM2Gg==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
     "node_modules/js-base64": {
       "version": "3.7.8",
       "license": "BSD-3-Clause"
@@ -9006,6 +10637,12 @@
       "version": "2.3.1",
       "license": "MIT"
     },
+    "node_modules/json-schema": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/json-schema/-/json-schema-0.4.0.tgz",
+      "integrity": "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA==",
+      "license": "(AFL-2.1 OR BSD-3-Clause)"
+    },
     "node_modules/json-schema-traverse": {
       "version": "0.4.1",
       "dev": true,
@@ -9390,6 +11027,8 @@
     },
     "node_modules/lodash": {
       "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
       "license": "MIT"
     },
     "node_modules/lodash.merge": {
@@ -9406,6 +11045,16 @@
       "version": "5.3.2",
       "license": "Apache-2.0"
     },
+    "node_modules/longest-streak": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/longest-streak/-/longest-streak-3.1.0.tgz",
+      "integrity": "sha512-9Ri+o0JYgehTaVBBDoMqIl8GXtbWg711O3srftcHhZ0dqnETqLaoIK0x17fUw9rFSlK/0NlsKe0Ahhyl5pXE2g==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/loose-envify": {
       "version": "1.4.0",
       "license": "MIT",
@@ -9482,6 +11131,159 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/mdast-util-from-markdown": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/mdast-util-from-markdown/-/mdast-util-from-markdown-2.0.3.tgz",
+      "integrity": "sha512-W4mAWTvSlKvf8L6J+VN9yLSqQ9AOAAvHuoDAmPkz4dHf553m5gVj2ejadHJhoJmcmxEnOv6Pa8XJhpxE93kb8Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark": "^4.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-expression": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-expression/-/mdast-util-mdx-expression-2.0.1.tgz",
+      "integrity": "sha512-J6f+9hUp+ldTZqKRSg7Vw5V6MqjATc+3E4gf3CFNcuZNWD8XdyI6zQ8GqH7f8169MM6P7hMBRDVGnn7oHB9kXQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdx-jsx": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdx-jsx/-/mdast-util-mdx-jsx-3.2.0.tgz",
+      "integrity": "sha512-lj/z8v0r6ZtsN/cGNNtemmmfoLAFZnjMbNyLzBafjzikOM+glrjNHPlf6lQDOTccj9n5b0PPihEBbhneMyGs1Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "ccount": "^2.0.0",
+        "devlop": "^1.1.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0",
+        "parse-entities": "^4.0.0",
+        "stringify-entities": "^4.0.0",
+        "unist-util-stringify-position": "^4.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-mdxjs-esm": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-mdxjs-esm/-/mdast-util-mdxjs-esm-2.0.1.tgz",
+      "integrity": "sha512-EcmOpxsZ96CvlP03NghtH1EsLtr0n9Tm4lPUJUBccV9RwUOneqSycg19n5HGzCf+10LozMRSObtVr3ee1WoHtg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/estree-jsx": "^1.0.0",
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "mdast-util-to-markdown": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-phrasing": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-phrasing/-/mdast-util-phrasing-4.1.0.tgz",
+      "integrity": "sha512-TqICwyvJJpBwvGAMZjj4J2n0X8QWp21b9l0o7eXyVJ25YNWYbJDVIyD1bZXE6WtV6RmKJVYmQAKWa0zWOABz2w==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-hast": {
+      "version": "13.2.1",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-hast/-/mdast-util-to-hast-13.2.1.tgz",
+      "integrity": "sha512-cctsq2wp5vTsLIcaymblUriiTcZd0CwWtCbLvrOzYCDZoWyMNV8sZ7krj09FSnsiJi3WVsHLM4k6Dq/yaPyCXA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "@ungap/structured-clone": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "trim-lines": "^3.0.0",
+        "unist-util-position": "^5.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-markdown": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-markdown/-/mdast-util-to-markdown-2.1.2.tgz",
+      "integrity": "sha512-xj68wMTvGXVOKonmog6LwyJKrYXZPvlwabaryTjLh9LuvovB/KAH+kvi8Gjj+7rJjsFi23nkUxRQv1KqSroMqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "@types/unist": "^3.0.0",
+        "longest-streak": "^3.0.0",
+        "mdast-util-phrasing": "^4.0.0",
+        "mdast-util-to-string": "^4.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-decode-string": "^2.0.0",
+        "unist-util-visit": "^5.0.0",
+        "zwitch": "^2.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/mdast-util-to-string": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mdast-util-to-string/-/mdast-util-to-string-4.0.0.tgz",
+      "integrity": "sha512-0H44vDimn51F0YwvxSJSm0eCDOJTRlmN0R1yBh4HLj9wiV1Dn0QoXGbvFAWj2hSItVTlCmBF1hqKlIyUBVFLPg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/memoize-one": {
       "version": "5.2.1",
       "license": "MIT",
@@ -9500,8 +11302,7 @@
     },
     "node_modules/merge-stream": {
       "version": "2.0.0",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/merge2": {
       "version": "1.4.1",
@@ -9867,6 +11668,448 @@
         "node": ">=12"
       }
     },
+    "node_modules/micromark": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/micromark/-/micromark-4.0.2.tgz",
+      "integrity": "sha512-zpe98Q6kvavpCr1NPVSCMebCKfD7CA2NqZ+rykeNhONIJBpc1tFKt9hucLGwha3jNTNI8lHpctWJWoimVF4PfA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "@types/debug": "^4.0.0",
+        "debug": "^4.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-core-commonmark": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-combine-extensions": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-sanitize-uri": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-core-commonmark": {
+      "version": "2.0.3",
+      "resolved": "https://registry.npmjs.org/micromark-core-commonmark/-/micromark-core-commonmark-2.0.3.tgz",
+      "integrity": "sha512-RDBrHEMSxVFLg6xvnXmb1Ayr2WzLAWjeSATAoxwKYJV94TeNavgoIdA0a9ytzDSVzBy2YKFK+emCPOEibLeCrg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "devlop": "^1.0.0",
+        "micromark-factory-destination": "^2.0.0",
+        "micromark-factory-label": "^2.0.0",
+        "micromark-factory-space": "^2.0.0",
+        "micromark-factory-title": "^2.0.0",
+        "micromark-factory-whitespace": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-classify-character": "^2.0.0",
+        "micromark-util-html-tag-name": "^2.0.0",
+        "micromark-util-normalize-identifier": "^2.0.0",
+        "micromark-util-resolve-all": "^2.0.0",
+        "micromark-util-subtokenize": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-destination": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-destination/-/micromark-factory-destination-2.0.1.tgz",
+      "integrity": "sha512-Xe6rDdJlkmbFRExpTOmRj9N3MaWmbAgdpSrBQvCFqhezUn4AHqJHbaEnfbVYYiexVSs//tqOdY/DxhjdCiJnIA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-label": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-label/-/micromark-factory-label-2.0.1.tgz",
+      "integrity": "sha512-VFMekyQExqIW7xIChcXn4ok29YE3rnuyveW3wZQWWqF4Nv9Wk5rgJ99KzPvHjkmPXF93FXIbBp6YdW3t71/7Vg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-space": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-space/-/micromark-factory-space-2.0.1.tgz",
+      "integrity": "sha512-zRkxjtBxxLd2Sc0d+fbnEunsTj46SWXgXciZmHq0kDYGnck/ZSGj9/wULTV95uoeYiK5hRXP2mJ98Uo4cq/LQg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-title": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-title/-/micromark-factory-title-2.0.1.tgz",
+      "integrity": "sha512-5bZ+3CjhAd9eChYTHsjy6TGxpOFSKgKKJPJxr293jTbfry2KDoWkhBb6TcPVB4NmzaPhMs1Frm9AZH7OD4Cjzw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-factory-whitespace": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-factory-whitespace/-/micromark-factory-whitespace-2.0.1.tgz",
+      "integrity": "sha512-Ob0nuZ3PKt/n0hORHyvoD9uZhr+Za8sFoP+OnMcnWK5lngSzALgQYKMr9RJVOWLqQYuyn6ulqGWSXdwf6F80lQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-factory-space": "^2.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-character": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-character/-/micromark-util-character-2.1.1.tgz",
+      "integrity": "sha512-wv8tdUTJ3thSFFFJKtpYKOYiGP2+v96Hvk4Tu8KpCAsTMs6yi+nVmGh1syvSCsaxz45J6Jbw+9DD6g97+NV67Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-chunked": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-chunked/-/micromark-util-chunked-2.0.1.tgz",
+      "integrity": "sha512-QUNFEOPELfmvv+4xiNg2sRYeS/P84pTW0TCgP5zc9FpXetHY0ab7SxKyAQCNCc1eK0459uoLI1y5oO5Vc1dbhA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-classify-character": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-classify-character/-/micromark-util-classify-character-2.0.1.tgz",
+      "integrity": "sha512-K0kHzM6afW/MbeWYWLjoHQv1sgg2Q9EccHEDzSkxiP/EaagNzCm7T/WMKZ3rjMbvIpvBiZgwR3dKMygtA4mG1Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-combine-extensions": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-combine-extensions/-/micromark-util-combine-extensions-2.0.1.tgz",
+      "integrity": "sha512-OnAnH8Ujmy59JcyZw8JSbK9cGpdVY44NKgSM7E9Eh7DiLS2E9RNQf0dONaGDzEG9yjEl5hcqeIsj4hfRkLH/Bg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-numeric-character-reference": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-numeric-character-reference/-/micromark-util-decode-numeric-character-reference-2.0.2.tgz",
+      "integrity": "sha512-ccUbYk6CwVdkmCQMyr64dXz42EfHGkPQlBj5p7YVGzq8I7CtjXZJrubAYezf7Rp+bjPseiROqe7G6foFd+lEuw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-decode-string": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-decode-string/-/micromark-util-decode-string-2.0.1.tgz",
+      "integrity": "sha512-nDV/77Fj6eH1ynwscYTOsbK7rR//Uj0bZXBwJZRfaLEJ1iGBR6kIfNmlNqaqJf649EP0F3NWNdeJi03elllNUQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "decode-named-character-reference": "^1.0.0",
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-decode-numeric-character-reference": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-encode": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-encode/-/micromark-util-encode-2.0.1.tgz",
+      "integrity": "sha512-c3cVx2y4KqUnwopcO9b/SCdo2O67LwJJ/UyqGfbigahfegL9myoEFoDYZgkT7f36T0bLrM9hZTAaAyH+PCAXjw==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-html-tag-name": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-html-tag-name/-/micromark-util-html-tag-name-2.0.1.tgz",
+      "integrity": "sha512-2cNEiYDhCWKI+Gs9T0Tiysk136SnR13hhO8yW6BGNyhOC4qYFnwF1nKfD3HFAIXA5c45RrIG1ub11GiXeYd1xA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-normalize-identifier": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-normalize-identifier/-/micromark-util-normalize-identifier-2.0.1.tgz",
+      "integrity": "sha512-sxPqmo70LyARJs0w2UclACPUUEqltCkJ6PhKdMIDuJ3gSf/Q+/GIe3WKl0Ijb/GyH9lOpUkRAO2wp0GVkLvS9Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-resolve-all": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-resolve-all/-/micromark-util-resolve-all-2.0.1.tgz",
+      "integrity": "sha512-VdQyxFWFT2/FGJgwQnJYbe1jjQoNTS4RjglmSjTUlpUMa95Htx9NHeYW4rGDJzbjvCsl9eLjMQwGeElsqmzcHg==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-sanitize-uri": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-sanitize-uri/-/micromark-util-sanitize-uri-2.0.1.tgz",
+      "integrity": "sha512-9N9IomZ/YuGGZZmQec1MbgxtlgougxTodVwDzzEouPKo3qFWvymFHWcnDi2vzV1ff6kas9ucW+o3yzJK9YB1AQ==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "micromark-util-character": "^2.0.0",
+        "micromark-util-encode": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-subtokenize": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/micromark-util-subtokenize/-/micromark-util-subtokenize-2.1.0.tgz",
+      "integrity": "sha512-XQLu552iSctvnEcgXw6+Sx75GflAPNED1qx7eBJ+wydBb2KCbRZe+NwvIEEMM83uml1+2WSXpBAcp9IUCgCYWA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "devlop": "^1.0.0",
+        "micromark-util-chunked": "^2.0.0",
+        "micromark-util-symbol": "^2.0.0",
+        "micromark-util-types": "^2.0.0"
+      }
+    },
+    "node_modules/micromark-util-symbol": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/micromark-util-symbol/-/micromark-util-symbol-2.0.1.tgz",
+      "integrity": "sha512-vs5t8Apaud9N28kgCrRUdEed4UJ+wWNvicHLPxCa9ENlYuAY31M0ETy5y1vA33YoNPDFTghEbnh6efaE8h4x0Q==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/micromark-util-types": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/micromark-util-types/-/micromark-util-types-2.0.2.tgz",
+      "integrity": "sha512-Yw0ECSpJoViF1qTU4DC6NwtC4aWGt1EkzaQB8KPPyCRR8z9TWeV0HbEFGTO+ZY1wB22zmxnJqhPyTpOVCpeHTA==",
+      "funding": [
+        {
+          "type": "GitHub Sponsors",
+          "url": "https://github.com/sponsors/unifiedjs"
+        },
+        {
+          "type": "OpenCollective",
+          "url": "https://opencollective.com/unified"
+        }
+      ],
+      "license": "MIT"
+    },
     "node_modules/micromatch": {
       "version": "4.0.8",
       "license": "MIT",
@@ -9922,6 +12165,24 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/mimic-fn": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/mimic-fn/-/mimic-fn-4.0.0.tgz",
+      "integrity": "sha512-vqiC06CuhBTUdZH+RYl8sFrL096vA45Ok5ISO6sE/Mr1jRbGH4Csnhi8f3wKVl7x8mO4Au7Ir9D3Oyv1VYMFJw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/minimal-polyfills": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/minimal-polyfills/-/minimal-polyfills-2.2.3.tgz",
+      "integrity": "sha512-oxdmJ9cL+xV72h0xYxp4tP2d5/fTBpP45H8DIOn9pASuF8a3IYTf+25fMGDYGiWW+MFsuog6KD6nfmhZJQ+uUw==",
+      "license": "MIT"
+    },
     "node_modules/minimatch": {
       "version": "3.1.5",
       "dev": true,
@@ -9952,6 +12213,44 @@
         "node": ">=10"
       }
     },
+    "node_modules/mlly": {
+      "version": "1.8.2",
+      "resolved": "https://registry.npmjs.org/mlly/-/mlly-1.8.2.tgz",
+      "integrity": "sha512-d+ObxMQFmbt10sretNDytwt85VrbkhhUA/JBGm1MPaWJ65Cl4wOgLaB1NYvJSZ0Ef03MMEU/0xpPMXUIQ29UfA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "acorn": "^8.16.0",
+        "pathe": "^2.0.3",
+        "pkg-types": "^1.3.1",
+        "ufo": "^1.6.3"
+      }
+    },
+    "node_modules/mlly/node_modules/confbox": {
+      "version": "0.1.8",
+      "resolved": "https://registry.npmjs.org/confbox/-/confbox-0.1.8.tgz",
+      "integrity": "sha512-RMtmw0iFkeR4YV+fUOSucriAQNb9g8zFR52MWCtl+cCZOFRNL6zeB395vPzFhEjjn4fMxXudmELnl/KF/WrK6w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/mlly/node_modules/pkg-types": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/pkg-types/-/pkg-types-1.3.1.tgz",
+      "integrity": "sha512-/Jm5M4RvtBFVkKWRu2BLUTNP8/M2a+UwuAX+ae4770q1qVGtfjG+WTCupoZixokjmHiry8uI+dlY8KXYV5HVVQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "confbox": "^0.1.8",
+        "mlly": "^1.7.4",
+        "pathe": "^2.0.1"
+      }
+    },
+    "node_modules/module-details-from-path": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/module-details-from-path/-/module-details-from-path-1.0.4.tgz",
+      "integrity": "sha512-EGWKgxALGMgzvxYF1UyGTy0HXX/2vHLkw6+NvDKW2jypWbHpjQuj4UMcqQWXHERJhVGKikolT06G3bcKe4fi7w==",
+      "license": "MIT"
+    },
     "node_modules/ms": {
       "version": "2.1.3",
       "license": "MIT"
@@ -10131,7 +12430,6 @@
     "node_modules/node-fetch": {
       "version": "2.7.0",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "whatwg-url": "^5.0.0"
       },
@@ -10147,6 +12445,13 @@
         }
       }
     },
+    "node_modules/node-fetch-native": {
+      "version": "1.6.7",
+      "resolved": "https://registry.npmjs.org/node-fetch-native/-/node-fetch-native-1.6.7.tgz",
+      "integrity": "sha512-g9yhqoedzIUm0nTnTqAQvueMPVOuIY16bqgAJJC8XOOubYFNwz6IER9qs0Gq2Xd0+CecCKFjtdDTMA4u4xG06Q==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/node-gyp-build": {
       "version": "4.8.4",
       "license": "MIT",
@@ -10167,11 +12472,73 @@
       "version": "2.0.44",
       "license": "MIT"
     },
+    "node_modules/npm-run-path": {
+      "version": "5.3.0",
+      "resolved": "https://registry.npmjs.org/npm-run-path/-/npm-run-path-5.3.0.tgz",
+      "integrity": "sha512-ppwTtiJZq0O/ai0z7yfudtBpWIoxM8yE6nHi1X47eFR2EWORqfbu6CnPlNsjeN683eT0qG6H/Pyf9fCcvjnnnQ==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^4.0.0"
+      },
+      "engines": {
+        "node": "^12.20.0 || ^14.13.1 || >=16.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/npm-run-path/node_modules/path-key": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-4.0.0.tgz",
+      "integrity": "sha512-haREypq7xkM7ErfgIyA0z+Bj4AGKlMSdlQE2jvJo6huWD1EdkKYV+G/T4nq0YEF2vgTT8kqMFKo1uHn950r4SQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/nullthrows": {
       "version": "1.1.1",
       "license": "MIT",
       "peer": true
     },
+    "node_modules/nypm": {
+      "version": "0.6.6",
+      "resolved": "https://registry.npmjs.org/nypm/-/nypm-0.6.6.tgz",
+      "integrity": "sha512-vRyr0r4cbBapw07Xw8xrj9Teq3o7MUD35rSaTcanDbW+aK2XHDgJFiU6ZTj2GBw7Q12ysdsyFss+Vdz4hQ0Y6Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "citty": "^0.2.2",
+        "pathe": "^2.0.3",
+        "tinyexec": "^1.1.1"
+      },
+      "bin": {
+        "nypm": "dist/cli.mjs"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/nypm/node_modules/citty": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/citty/-/citty-0.2.2.tgz",
+      "integrity": "sha512-+6vJA3L98yv+IdfKGZHBNiGW5KHn22e/JwID0Strsz8h4S/csAu/OuICwxrg44k5MRiZHWIo8XXuJgQTriRP4w==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/nypm/node_modules/tinyexec": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.2.tgz",
+      "integrity": "sha512-M/Q0B2cp4K7kynaT/vnED1j8TlLY+Pp7C6Wl2bl/7u/F0mUVwdyOpwomQb8JpYLitHUssAJRmLZdMCGsrx7i+g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
     "node_modules/ob1": {
       "version": "0.84.4",
       "license": "MIT",
@@ -10185,7 +12552,6 @@
     },
     "node_modules/object-assign": {
       "version": "4.1.1",
-      "dev": true,
       "license": "MIT",
       "engines": {
         "node": ">=0.10.0"
@@ -10305,6 +12671,21 @@
         "node": ">= 0.8"
       }
     },
+    "node_modules/onetime": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/onetime/-/onetime-6.0.0.tgz",
+      "integrity": "sha512-1FlR+gjXK7X+AsAHso35MnyN5KqGwJRi/31ft6x0M194ht7S+rWAvd7PHss9xSKMzE0asv1pyIHaJYq+BbacAQ==",
+      "license": "MIT",
+      "dependencies": {
+        "mimic-fn": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/open": {
       "version": "7.4.2",
       "license": "MIT",
@@ -10397,6 +12778,31 @@
         "node": ">=6"
       }
     },
+    "node_modules/parse-entities": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/parse-entities/-/parse-entities-4.0.2.tgz",
+      "integrity": "sha512-GG2AQYWoLgL877gQIKeRPGO1xF9+eG1ujIb5soS5gPvLQ1y2o8FL90w2QWNdf9I361Mpp7726c+lj3U0qK1uGw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^2.0.0",
+        "character-entities-legacy": "^3.0.0",
+        "character-reference-invalid": "^2.0.0",
+        "decode-named-character-reference": "^1.0.0",
+        "is-alphanumerical": "^2.0.0",
+        "is-decimal": "^2.0.0",
+        "is-hexadecimal": "^2.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/parse-entities/node_modules/@types/unist": {
+      "version": "2.0.11",
+      "resolved": "https://registry.npmjs.org/@types/unist/-/unist-2.0.11.tgz",
+      "integrity": "sha512-CmBKiL6NNo/OqgmMn95Fk9Whlp2mtvIv+KNpQKN2F4SjvrEesubTRWGYSg+BnWZOnlCaSTU1sMpsBOzgbYhnsA==",
+      "license": "MIT"
+    },
     "node_modules/parse-json": {
       "version": "5.2.0",
       "license": "MIT",
@@ -10699,6 +13105,19 @@
         }
       }
     },
+    "node_modules/prom-client": {
+      "version": "15.1.3",
+      "resolved": "https://registry.npmjs.org/prom-client/-/prom-client-15.1.3.tgz",
+      "integrity": "sha512-6ZiOBfCywsD4k1BN9IX0uZhF+tJkV8q8llP64G5Hajs4JOeVLPCwpPVcpXy3BwYiUGgyJzsJJQeOIv7+hDSq8g==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@opentelemetry/api": "^1.4.0",
+        "tdigest": "^0.1.1"
+      },
+      "engines": {
+        "node": "^16 || ^18 || >=20"
+      }
+    },
     "node_modules/promise": {
       "version": "8.3.0",
       "license": "MIT",
@@ -10730,6 +13149,40 @@
       "version": "3.0.7",
       "license": "ISC"
     },
+    "node_modules/property-information": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz",
+      "integrity": "sha512-IAtzIB6sUiWaJYrX9smp3V46pBGbBeLFRGdh25kg1334VcBlD8HzhPeNIWQH9zhGmo2itIe25EHt9dQP7G5hmg==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/protobufjs": {
+      "version": "7.6.1",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.6.1.tgz",
+      "integrity": "sha512-4K0myLaWL5EteuSAro91EGFgcfVgxb64Jx+7oDAY6GOkXD4M69yuSEljNcInGVCA5sOPxmZ/EqDLj2x0Q0+Ygg==",
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.5",
+        "@protobufjs/eventemitter": "^1.1.1",
+        "@protobufjs/fetch": "^1.1.1",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/inquire": "^1.1.2",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.1",
+        "@types/node": ">=13.7.0",
+        "long": "^5.3.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
     "node_modules/punycode": {
       "version": "2.3.1",
       "dev": true,
@@ -10903,6 +13356,8 @@
     },
     "node_modules/radix-ui": {
       "version": "1.4.3",
+      "resolved": "https://registry.npmjs.org/radix-ui/-/radix-ui-1.4.3.tgz",
+      "integrity": "sha512-aWizCQiyeAenIdUbqEpXgRA1ya65P13NKn/W8rWkcN0OPkRDxdBVLWnIEDsS2RpwCK2nobI7oMUSmexzTDyAmA==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/primitive": "1.1.3",
@@ -10978,6 +13433,8 @@
     },
     "node_modules/radix-ui/node_modules/@radix-ui/react-slot": {
       "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@radix-ui/react-slot/-/react-slot-1.2.3.tgz",
+      "integrity": "sha512-aeNmHnBxbi2St0au6VBVC7JXFlhLlOnvIIlePNniyUNAClzmtAUEY8/pBiK3iHjufOlwA+c20/8jngo7xcrg8A==",
       "license": "MIT",
       "dependencies": {
         "@radix-ui/react-compose-refs": "1.1.2"
@@ -11038,6 +13495,33 @@
       "version": "16.13.1",
       "license": "MIT"
     },
+    "node_modules/react-markdown": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/react-markdown/-/react-markdown-10.1.0.tgz",
+      "integrity": "sha512-qKxVopLT/TyA6BX3Ue5NwabOsAzm0Q7kAPwq6L+wWDwisYs7R8vZ0nRXqq6rkueboxpkjvLGU9fWifiX/ZZFxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "devlop": "^1.0.0",
+        "hast-util-to-jsx-runtime": "^2.0.0",
+        "html-url-attributes": "^3.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "remark-parse": "^11.0.0",
+        "remark-rehype": "^11.0.0",
+        "unified": "^11.0.0",
+        "unist-util-visit": "^5.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      },
+      "peerDependencies": {
+        "@types/react": ">=18",
+        "react": ">=18"
+      }
+    },
     "node_modules/react-native": {
       "version": "0.85.3",
       "license": "MIT",
@@ -11304,6 +13788,39 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/remark-parse": {
+      "version": "11.0.0",
+      "resolved": "https://registry.npmjs.org/remark-parse/-/remark-parse-11.0.0.tgz",
+      "integrity": "sha512-FCxlKLNGknS5ba/1lmpYijMUzX2esxW5xQqjWxw2eHFfS2MSdaHVINFmhjo+qN1WhZhNimq0dZATN9pH0IDrpA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/mdast": "^4.0.0",
+        "mdast-util-from-markdown": "^2.0.0",
+        "micromark-util-types": "^2.0.0",
+        "unified": "^11.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/remark-rehype": {
+      "version": "11.1.2",
+      "resolved": "https://registry.npmjs.org/remark-rehype/-/remark-rehype-11.1.2.tgz",
+      "integrity": "sha512-Dh7l57ianaEoIpzbp0PC9UKAdCSVklD8E5Rpw7ETfbTl3FqcOOgq5q2LVDhgGCkaBv7p24JXikPdvhhmHvKMsw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/hast": "^3.0.0",
+        "@types/mdast": "^4.0.0",
+        "mdast-util-to-hast": "^13.0.0",
+        "unified": "^11.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/remeda": {
       "version": "2.33.4",
       "license": "MIT",
@@ -11325,6 +13842,41 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/require-in-the-middle": {
+      "version": "7.5.2",
+      "resolved": "https://registry.npmjs.org/require-in-the-middle/-/require-in-the-middle-7.5.2.tgz",
+      "integrity": "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.3.5",
+        "module-details-from-path": "^1.0.3",
+        "resolve": "^1.22.8"
+      },
+      "engines": {
+        "node": ">=8.6.0"
+      }
+    },
+    "node_modules/require-in-the-middle/node_modules/resolve": {
+      "version": "1.22.12",
+      "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz",
+      "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "is-core-module": "^2.16.1",
+        "path-parse": "^1.0.7",
+        "supports-preserve-symlinks-flag": "^1.0.0"
+      },
+      "bin": {
+        "resolve": "bin/resolve"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
     "node_modules/require-main-filename": {
       "version": "2.0.0",
       "license": "ISC"
@@ -11448,6 +14000,15 @@
         }
       }
     },
+    "node_modules/run-exclusive": {
+      "version": "2.2.19",
+      "resolved": "https://registry.npmjs.org/run-exclusive/-/run-exclusive-2.2.19.tgz",
+      "integrity": "sha512-K3mdoAi7tjJ/qT7Flj90L7QyPozwUaAG+CVhkdDje4HLKXUYC3N/Jzkau3flHVDLQVhiHBtcimVodMjN9egYbA==",
+      "license": "MIT",
+      "dependencies": {
+        "minimal-polyfills": "^2.2.3"
+      }
+    },
     "node_modules/run-parallel": {
       "version": "1.2.0",
       "dev": true,
@@ -11548,6 +14109,8 @@
     },
     "node_modules/scroll-into-view-if-needed": {
       "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/scroll-into-view-if-needed/-/scroll-into-view-if-needed-3.1.0.tgz",
+      "integrity": "sha512-49oNpRjWRvnU8NyGVmUaYG4jtTkNonFZI86MmGRDqBphEK2EXT9gdEUoQPZhuBM8yWHxCWbobltqYO5M4XrUvQ==",
       "license": "MIT",
       "dependencies": {
         "compute-scroll-into-view": "^3.0.2"
@@ -11874,6 +14437,8 @@
     },
     "node_modules/slate": {
       "version": "0.110.2",
+      "resolved": "https://registry.npmjs.org/slate/-/slate-0.110.2.tgz",
+      "integrity": "sha512-4xGULnyMCiEQ0Ml7JAC1A6HVE6MNpPJU7Eq4cXh1LxlrR0dFXC3XC+rNfQtUJ7chHoPkws57x7DDiWiZAt+PBA==",
       "license": "MIT",
       "dependencies": {
         "immer": "^10.0.3",
@@ -11881,42 +14446,208 @@
         "tiny-warning": "^1.0.3"
       }
     },
-    "node_modules/slate-history": {
-      "version": "0.110.3",
+    "node_modules/slate-history": {
+      "version": "0.110.3",
+      "resolved": "https://registry.npmjs.org/slate-history/-/slate-history-0.110.3.tgz",
+      "integrity": "sha512-sgdff4Usdflmw5ZUbhDkxFwCBQ2qlDKMMkF93w66KdV48vHOgN2BmLrf+2H8SdX8PYIpP/cTB0w8qWC2GwhDVA==",
+      "license": "MIT",
+      "dependencies": {
+        "is-plain-object": "^5.0.0"
+      },
+      "peerDependencies": {
+        "slate": ">=0.65.3"
+      }
+    },
+    "node_modules/slate-hyperscript": {
+      "version": "0.100.0",
+      "resolved": "https://registry.npmjs.org/slate-hyperscript/-/slate-hyperscript-0.100.0.tgz",
+      "integrity": "sha512-fb2KdAYg6RkrQGlqaIi4wdqz3oa0S4zKNBJlbnJbNOwa23+9FLD6oPVx9zUGqCSIpy+HIpOeqXrg0Kzwh/Ii4A==",
+      "license": "MIT",
+      "dependencies": {
+        "is-plain-object": "^5.0.0"
+      },
+      "peerDependencies": {
+        "slate": ">=0.65.3"
+      }
+    },
+    "node_modules/slate-react": {
+      "version": "0.110.3",
+      "resolved": "https://registry.npmjs.org/slate-react/-/slate-react-0.110.3.tgz",
+      "integrity": "sha512-AS8PPjwmsFS3Lq0MOEegLVlFoxhyos68G6zz2nW4sh3WeTXV7pX0exnwtY1a/docn+J3LGQO11aZXTenPXA/kg==",
+      "license": "MIT",
+      "dependencies": {
+        "@juggle/resize-observer": "^3.4.0",
+        "direction": "^1.0.4",
+        "is-hotkey": "^0.2.0",
+        "is-plain-object": "^5.0.0",
+        "lodash": "^4.17.21",
+        "scroll-into-view-if-needed": "^3.1.0",
+        "tiny-invariant": "1.3.1"
+      },
+      "peerDependencies": {
+        "react": ">=18.2.0",
+        "react-dom": ">=18.2.0",
+        "slate": ">=0.99.0"
+      }
+    },
+    "node_modules/slug": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/slug/-/slug-6.1.0.tgz",
+      "integrity": "sha512-x6vLHCMasg4DR2LPiyFGI0gJJhywY6DTiGhCrOMzb3SOk/0JVLIaL4UhyFSHu04SD3uAavrKY/K3zZ3i6iRcgA==",
+      "license": "MIT"
+    },
+    "node_modules/socket.io": {
+      "version": "4.7.4",
+      "resolved": "https://registry.npmjs.org/socket.io/-/socket.io-4.7.4.tgz",
+      "integrity": "sha512-DcotgfP1Zg9iP/dH9zvAQcWrE0TtbMVwXmlV4T4mqsvY+gw+LqUGPfx2AoVyRk0FLME+GQhufDMyacFmw7ksqw==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.4",
+        "base64id": "~2.0.0",
+        "cors": "~2.8.5",
+        "debug": "~4.3.2",
+        "engine.io": "~6.5.2",
+        "socket.io-adapter": "~2.5.2",
+        "socket.io-parser": "~4.2.4"
+      },
+      "engines": {
+        "node": ">=10.2.0"
+      }
+    },
+    "node_modules/socket.io-adapter": {
+      "version": "2.5.7",
+      "resolved": "https://registry.npmjs.org/socket.io-adapter/-/socket.io-adapter-2.5.7.tgz",
+      "integrity": "sha512-e0LyK91f3cUxTmv95/KzoLg47+zF+s/sbxRGDNsyG4dmIP8ZSX8ax6byOxfJXeNNtS/8AZlfD+uP7gBeR7DLlg==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "~4.4.1",
+        "ws": "~8.20.1"
+      }
+    },
+    "node_modules/socket.io-adapter/node_modules/ws": {
+      "version": "8.20.1",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.20.1.tgz",
+      "integrity": "sha512-It4dO0K5v//JtTXuPkfEOaI3uUN87iYPnqo/ZzqCoG3g8uhA66QUMs/SrM0YK7/NAu+r4LMh/9dq2A7k+rHs+w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io-client": {
+      "version": "4.7.5",
+      "resolved": "https://registry.npmjs.org/socket.io-client/-/socket.io-client-4.7.5.tgz",
+      "integrity": "sha512-sJ/tqHOCe7Z50JCBCXrsY3I2k03iOiUe+tj1OmKeD2lXPiGH/RUCdTZFoqVyN7l1MnpIzPrGtLcijffmeouNlQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.3.2",
+        "engine.io-client": "~6.5.2",
+        "socket.io-parser": "~4.2.4"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/socket.io-client/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "^2.1.3"
+      },
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/socket.io-parser": {
+      "version": "4.2.6",
+      "resolved": "https://registry.npmjs.org/socket.io-parser/-/socket.io-parser-4.2.6.tgz",
+      "integrity": "sha512-asJqbVBDsBCJx0pTqw3WfesSY0iRX+2xzWEWzrpcH7L6fLzrhyF8WPI8UaeM4YCuDfpwA/cgsdugMsmtz8EJeg==",
+      "license": "MIT",
+      "dependencies": {
+        "@socket.io/component-emitter": "~3.1.0",
+        "debug": "~4.4.1"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/socket.io/node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
       "license": "MIT",
       "dependencies": {
-        "is-plain-object": "^5.0.0"
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
       },
-      "peerDependencies": {
-        "slate": ">=0.65.3"
+      "engines": {
+        "node": ">= 0.6"
       }
     },
-    "node_modules/slate-hyperscript": {
-      "version": "0.100.0",
+    "node_modules/socket.io/node_modules/debug": {
+      "version": "4.3.7",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-4.3.7.tgz",
+      "integrity": "sha512-Er2nc/H7RrMXZBFCEim6TCmMk02Z8vLC2Rbi1KEBggpo0fS6l0S1nnapwmIi3yW/+GOJap1Krg4w0Hg80oCqgQ==",
       "license": "MIT",
       "dependencies": {
-        "is-plain-object": "^5.0.0"
+        "ms": "^2.1.3"
       },
-      "peerDependencies": {
-        "slate": ">=0.65.3"
+      "engines": {
+        "node": ">=6.0"
+      },
+      "peerDependenciesMeta": {
+        "supports-color": {
+          "optional": true
+        }
       }
     },
-    "node_modules/slate-react": {
-      "version": "0.110.3",
+    "node_modules/socket.io/node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/socket.io/node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
       "license": "MIT",
       "dependencies": {
-        "@juggle/resize-observer": "^3.4.0",
-        "direction": "^1.0.4",
-        "is-hotkey": "^0.2.0",
-        "is-plain-object": "^5.0.0",
-        "lodash": "^4.17.21",
-        "scroll-into-view-if-needed": "^3.1.0",
-        "tiny-invariant": "1.3.1"
+        "mime-db": "1.52.0"
       },
-      "peerDependencies": {
-        "react": ">=18.2.0",
-        "react-dom": ">=18.2.0",
-        "slate": ">=0.99.0"
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/socket.io/node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
       }
     },
     "node_modules/source-map": {
@@ -11950,6 +14681,16 @@
         "node": ">=0.10.0"
       }
     },
+    "node_modules/space-separated-tokens": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/space-separated-tokens/-/space-separated-tokens-2.0.2.tgz",
+      "integrity": "sha512-PEGlAwrG8yXGXRjW32fGbg66JAlOAwbObuqVoJpv/mRgoWDQfgH1wDPvtzWyUSNAXBGSk8h755YDbbcEy3SH2Q==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/split2": {
       "version": "4.2.0",
       "license": "ISC",
@@ -12147,6 +14888,20 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/stringify-entities": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/stringify-entities/-/stringify-entities-4.0.4.tgz",
+      "integrity": "sha512-IwfBptatlO+QCJUo19AqvrPNqlVMpW9YEL2LIVY+Rpv2qsjCGxaDLNRgeGsQWJhfItebuJhsGSLjaBbNSQ+ieg==",
+      "license": "MIT",
+      "dependencies": {
+        "character-entities-html4": "^2.0.0",
+        "character-entities-legacy": "^3.0.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
     "node_modules/strip-ansi": {
       "version": "6.0.1",
       "license": "MIT",
@@ -12165,6 +14920,18 @@
         "node": ">=4"
       }
     },
+    "node_modules/strip-final-newline": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/strip-final-newline/-/strip-final-newline-3.0.0.tgz",
+      "integrity": "sha512-dOESqjYr96iWYylGObzd39EuNTa5VJxyvVAEm5Jnh7KGo75V43Hk1odPQkNDyXNmUR6k+gEiDVXnjB8HJ3crXw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
     "node_modules/strip-json-comments": {
       "version": "3.1.1",
       "dev": true,
@@ -12176,6 +14943,24 @@
         "url": "https://github.com/sponsors/sindresorhus"
       }
     },
+    "node_modules/style-to-js": {
+      "version": "1.1.21",
+      "resolved": "https://registry.npmjs.org/style-to-js/-/style-to-js-1.1.21.tgz",
+      "integrity": "sha512-RjQetxJrrUJLQPHbLku6U/ocGtzyjbJMP9lCNK7Ag0CNh690nSH8woqWH9u16nMjYBAok+i7JO1NP2pOy8IsPQ==",
+      "license": "MIT",
+      "dependencies": {
+        "style-to-object": "1.0.14"
+      }
+    },
+    "node_modules/style-to-object": {
+      "version": "1.0.14",
+      "resolved": "https://registry.npmjs.org/style-to-object/-/style-to-object-1.0.14.tgz",
+      "integrity": "sha512-LIN7rULI0jBscWQYaSswptyderlarFkjQ+t79nzty8tcIAceVomEVlLzH5VP4Cmsv6MtKhs7qaAiwlcp+Mgaxw==",
+      "license": "MIT",
+      "dependencies": {
+        "inline-style-parser": "0.2.7"
+      }
+    },
     "node_modules/styled-jsx": {
       "version": "5.1.6",
       "license": "MIT",
@@ -12229,6 +15014,45 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/swr": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/swr/-/swr-2.4.1.tgz",
+      "integrity": "sha512-2CC6CiKQtEwaEeNiqWTAw9PGykW8SR5zZX8MZk6TeAvEAnVS7Visz8WzphqgtQ8v2xz/4Q5K+j+SeMaKXeeQIA==",
+      "license": "MIT",
+      "dependencies": {
+        "dequal": "^2.0.3",
+        "use-sync-external-store": "^1.6.0"
+      },
+      "peerDependencies": {
+        "react": "^16.11.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"
+      }
+    },
+    "node_modules/systeminformation": {
+      "version": "5.23.8",
+      "resolved": "https://registry.npmjs.org/systeminformation/-/systeminformation-5.23.8.tgz",
+      "integrity": "sha512-Osd24mNKe6jr/YoXLLK3k8TMdzaxDffhpCxgkfgBHcapykIkd50HXThM3TCEuHO2pPuCsSx2ms/SunqhU5MmsQ==",
+      "license": "MIT",
+      "os": [
+        "darwin",
+        "linux",
+        "win32",
+        "freebsd",
+        "openbsd",
+        "netbsd",
+        "sunos",
+        "android"
+      ],
+      "bin": {
+        "systeminformation": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=8.0.0"
+      },
+      "funding": {
+        "type": "Buy me a coffee",
+        "url": "https://www.buymeacoffee.com/systeminfo"
+      }
+    },
     "node_modules/tabbable": {
       "version": "6.4.0",
       "license": "MIT"
@@ -12258,6 +15082,15 @@
         "url": "https://opencollective.com/webpack"
       }
     },
+    "node_modules/tdigest": {
+      "version": "0.1.2",
+      "resolved": "https://registry.npmjs.org/tdigest/-/tdigest-0.1.2.tgz",
+      "integrity": "sha512-+G0LLgjjo9BZX2MfdvPfH+MKLCrxlXSYec5DaPYP1fe6Iyhf0/fSmJ0bFiZ1F8BT6cGXl2LpltQptzjXKWEkKA==",
+      "license": "MIT",
+      "dependencies": {
+        "bintrees": "1.0.2"
+      }
+    },
     "node_modules/terser": {
       "version": "5.47.1",
       "license": "BSD-2-Clause",
@@ -12303,10 +15136,20 @@
     },
     "node_modules/tiny-invariant": {
       "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/tiny-invariant/-/tiny-invariant-1.3.1.tgz",
+      "integrity": "sha512-AD5ih2NlSssTCwsMznbvwMZpJ1cbhkGd2uueNxzv2jDlEeZdU04JQfRnggJQ8DrcVBGjAsCKwFBbDlVNtEMlzw==",
       "license": "MIT"
     },
     "node_modules/tiny-warning": {
       "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/tiny-warning/-/tiny-warning-1.0.3.tgz",
+      "integrity": "sha512-lBN9zLN/oAf68o3zNXYrdCt1kP8WsiGW8Oo2ka41b2IM5JL/S1CTyX1rW0mb/zSuJun0ZUrDxx4sqvYS2FWzPA==",
+      "license": "MIT"
+    },
+    "node_modules/tinyexec": {
+      "version": "0.3.2",
+      "resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-0.3.2.tgz",
+      "integrity": "sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==",
       "license": "MIT"
     },
     "node_modules/tinyglobby": {
@@ -12377,8 +15220,27 @@
     },
     "node_modules/tr46": {
       "version": "0.0.3",
+      "license": "MIT"
+    },
+    "node_modules/trim-lines": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/trim-lines/-/trim-lines-3.0.1.tgz",
+      "integrity": "sha512-kRj8B+YHZCc9kQYdWfJB2/oUl9rA99qbowYYBtr4ui4mZyAQ2JpvVBd/6U2YloATfqBhBTSMhTpgBHtU0Mf3Rg==",
       "license": "MIT",
-      "peer": true
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/trough": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/trough/-/trough-2.2.0.tgz",
+      "integrity": "sha512-tmMpK00BjZiUyVyvrBK7knerNgmgvcV/KLVyuma/SC+TQN167GrMRciANTz09+k3zW8L8t60jWO1GpfkZdjTaw==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     },
     "node_modules/ts-api-utils": {
       "version": "2.5.0",
@@ -12391,6 +15253,33 @@
         "typescript": ">=4.8.4"
       }
     },
+    "node_modules/tsafe": {
+      "version": "1.8.12",
+      "resolved": "https://registry.npmjs.org/tsafe/-/tsafe-1.8.12.tgz",
+      "integrity": "sha512-nFRqW0ttu/2o6XTXsHiVZWJBCOaxhVqZLg7dgs3coZNsCMPXPfwz+zPHAQA+70fNnVJLAPg1EgGIqK9Q84tvAw==",
+      "license": "MIT"
+    },
+    "node_modules/tsconfck": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/tsconfck/-/tsconfck-3.1.3.tgz",
+      "integrity": "sha512-ulNZP1SVpRDesxeMLON/LtWM8HIgAJEIVpVVhBM6gsmvQ8+Rh+ZG7FWGvHh7Ah3pRABwVJWklWCr/BTZSv0xnQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "tsconfck": "bin/tsconfck.js"
+      },
+      "engines": {
+        "node": "^18 || >=20"
+      },
+      "peerDependencies": {
+        "typescript": "^5.0.0"
+      },
+      "peerDependenciesMeta": {
+        "typescript": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/tsconfig-paths": {
       "version": "3.15.0",
       "dev": true,
@@ -12555,6 +15444,22 @@
         "typescript": ">=4.8.4 <6.1.0"
       }
     },
+    "node_modules/ufo": {
+      "version": "1.6.4",
+      "resolved": "https://registry.npmjs.org/ufo/-/ufo-1.6.4.tgz",
+      "integrity": "sha512-JFNbkD1Svwe0KvGi8GOeLcP4kAWQ609twvCdcHxq1oSL8svv39ZuSvajcD8B+5D0eL4+s1Is2D/O6KN3qcTeRA==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ulid": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/ulid/-/ulid-2.4.0.tgz",
+      "integrity": "sha512-fIRiVTJNcSRmXKPZtGzFQv9WRrZ3M9eoptl/teFJvjOzmpU+/K/JH6HZ8deBfb5vMEpicJcLn7JmvdknlMq7Zg==",
+      "license": "MIT",
+      "bin": {
+        "ulid": "bin/cli.js"
+      }
+    },
     "node_modules/unbox-primitive": {
       "version": "1.1.0",
       "dev": true,
@@ -12572,6 +15477,12 @@
         "url": "https://github.com/sponsors/ljharb"
       }
     },
+    "node_modules/uncrypto": {
+      "version": "0.1.3",
+      "resolved": "https://registry.npmjs.org/uncrypto/-/uncrypto-0.1.3.tgz",
+      "integrity": "sha512-Ql87qFHB3s/De2ClA9e0gsnS6zXG27SkTiSJwjCc9MebbfapQfuPzumMIUMi38ezPZVNFcHI9sUIepeQfw8J8Q==",
+      "license": "MIT"
+    },
     "node_modules/undici": {
       "version": "6.26.0",
       "resolved": "https://registry.npmjs.org/undici/-/undici-6.26.0.tgz",
@@ -12585,6 +15496,105 @@
       "version": "6.21.0",
       "license": "MIT"
     },
+    "node_modules/unified": {
+      "version": "11.0.5",
+      "resolved": "https://registry.npmjs.org/unified/-/unified-11.0.5.tgz",
+      "integrity": "sha512-xKvGhPWw3k84Qjh8bI3ZeJjqnyadK+GEFtazSfZv/rKeTkTjOJho6mFqh2SM96iIcZokxiOpg78GazTSg8+KHA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "bail": "^2.0.0",
+        "devlop": "^1.0.0",
+        "extend": "^3.0.0",
+        "is-plain-obj": "^4.0.0",
+        "trough": "^2.0.0",
+        "vfile": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unified/node_modules/is-plain-obj": {
+      "version": "4.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-4.1.0.tgz",
+      "integrity": "sha512-+Pgi+vMuUNkJyExiMBt5IlFoMyKnr5zhJ4Uspz58WOhBF5QoIZkFyNHIbBAtHwzVAgk5RtndVNsDRN61/mmDqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/unist-util-is": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/unist-util-is/-/unist-util-is-6.0.1.tgz",
+      "integrity": "sha512-LsiILbtBETkDz8I9p1dQ0uyRUWuaQzd/cuEeS1hoRSyW5E5XGmTzlwY1OrNzzakGowI9Dr/I8HVaw4hTtnxy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-position": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-position/-/unist-util-position-5.0.0.tgz",
+      "integrity": "sha512-fucsC7HjXvkB5R3kTCO7kUjRdrS0BJt3M/FPxmHMBOm8JQi2BsHAHFsy27E0EolP8rp0NzXsJ+jNPyDWvOJZPA==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-stringify-position": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/unist-util-stringify-position/-/unist-util-stringify-position-4.0.0.tgz",
+      "integrity": "sha512-0ASV06AAoKCDkS2+xw5RXJywruurpbC4JZSm7nr7MOt1ojAzvyyaO+UxZf18j8FCF6kmzCZKcAgN/yu2gm2XgQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/unist-util-visit/-/unist-util-visit-5.1.0.tgz",
+      "integrity": "sha512-m+vIdyeCOpdr/QeQCu2EzxX/ohgS8KbnPDgFni4dQsfSCtpz8UqDyY5GjRru8PDKuYn7Fq19j1CQ+nJSsGKOzg==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0",
+        "unist-util-visit-parents": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/unist-util-visit-parents": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/unist-util-visit-parents/-/unist-util-visit-parents-6.0.2.tgz",
+      "integrity": "sha512-goh1s1TBrqSqukSc8wrjwWhL0hiJxgA8m4kFxGlQ+8FYQ3C/m11FcTs4YYem7V664AhHVvgoQLk890Ssdsr2IQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-is": "^6.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/unpipe": {
       "version": "1.0.0",
       "license": "MIT",
@@ -12739,6 +15749,43 @@
         }
       }
     },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/vfile": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",
+      "integrity": "sha512-KzIbH/9tXat2u30jf+smMwFCsno4wHVdNmzFyL+T/L3UGqqk6JKfVqOFOZEpZSHADH1k40ab6NUIXZq422ov3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "vfile-message": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
+    "node_modules/vfile-message": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/vfile-message/-/vfile-message-4.0.3.tgz",
+      "integrity": "sha512-QTHzsGd1EhbZs4AsQ20JX1rC3cOlt/IWJruk893DfLRr57lcnOeMaWG4K0JrRta4mIJZKth2Au3mM3u03/JWKw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/unist": "^3.0.0",
+        "unist-util-stringify-position": "^4.0.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/unified"
+      }
+    },
     "node_modules/vlq": {
       "version": "1.0.1",
       "license": "MIT",
@@ -12754,8 +15801,7 @@
     },
     "node_modules/webidl-conversions": {
       "version": "3.0.1",
-      "license": "BSD-2-Clause",
-      "peer": true
+      "license": "BSD-2-Clause"
     },
     "node_modules/whatwg-fetch": {
       "version": "3.6.20",
@@ -12765,7 +15811,6 @@
     "node_modules/whatwg-url": {
       "version": "5.0.0",
       "license": "MIT",
-      "peer": true,
       "dependencies": {
         "tr46": "~0.0.3",
         "webidl-conversions": "^3.0.0"
@@ -12897,6 +15942,14 @@
         }
       }
     },
+    "node_modules/xmlhttprequest-ssl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/xmlhttprequest-ssl/-/xmlhttprequest-ssl-2.0.0.tgz",
+      "integrity": "sha512-QKxVRxiRACQcVuQEYFsI1hhkrMlrXHPegbbd1yn9UHOmRxY+si12nQYzri3vbzt8VdTTRviqcKxcyllFas5z2A==",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
     "node_modules/xtend": {
       "version": "4.0.2",
       "license": "MIT",
@@ -12936,7 +15989,24 @@
     },
     "node_modules/zod": {
       "version": "4.4.3",
-      "dev": true,
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    },
+    "node_modules/zod-error": {
+      "version": "1.5.0",
+      "resolved": "https://registry.npmjs.org/zod-error/-/zod-error-1.5.0.tgz",
+      "integrity": "sha512-zzopKZ/skI9iXpqCEPj+iLCKl9b88E43ehcU+sbRoHuwGd9F1IDVGQ70TyO6kmfiRL1g4IXkjsXK+g1gLYl4WQ==",
+      "license": "MIT",
+      "dependencies": {
+        "zod": "^3.20.2"
+      }
+    },
+    "node_modules/zod-error/node_modules/zod": {
+      "version": "3.25.76",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-3.25.76.tgz",
+      "integrity": "sha512-gzUt/qt81nXsFGKIFcC3YnfEAx5NkunCfnDlvuBSSFS02bcXu4Lmea0AFIUwbLWxWPx3d9p8S5QoaujKcNQxcQ==",
       "license": "MIT",
       "funding": {
         "url": "https://github.com/sponsors/colinhacks"
@@ -12978,6 +16048,16 @@
           "optional": true
         }
       }
+    },
+    "node_modules/zwitch": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/zwitch/-/zwitch-2.0.4.tgz",
+      "integrity": "sha512-bXE4cR/kVZhKZX/RjPEflHaKVhUVl85noU3v6b8apfQEc1x4A+zBxjZ4lN8LqGd6WZ3dl98pY4o717VFmoPp+A==",
+      "license": "MIT",
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/wooorm"
+      }
     }
   }
 }
diff --git a/package.json b/package.json
index 1d3b4bb..6d4a161 100644
--- a/package.json
+++ b/package.json
@@ -9,21 +9,26 @@
     "lint": "eslint"
   },
   "dependencies": {
+    "@ai-sdk/google": "^3.0.80",
     "@clerk/nextjs": "^7.3.4",
     "@clerk/ui": "^1.10.0",
-    "@liveblocks/client": "^3.19.2",
-    "@liveblocks/react": "^3.19.2",
-    "@liveblocks/react-flow": "^3.19.2",
-    "@liveblocks/react-ui": "^3.19.2",
+    "@liveblocks/client": "^3.19.3",
+    "@liveblocks/node": "^3.19.3",
+    "@liveblocks/react": "^3.19.3",
+    "@liveblocks/react-flow": "^3.19.3",
+    "@liveblocks/react-ui": "^3.19.3",
     "@prisma/adapter-pg": "^7.8.0",
     "@prisma/client": "^7.8.0",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-scroll-area": "^1.2.10",
     "@radix-ui/react-slot": "^1.2.4",
     "@radix-ui/react-tabs": "^1.1.13",
+    "@trigger.dev/react-hooks": "^4.4.6",
+    "@trigger.dev/sdk": "^4.4.6",
     "@types/pg": "^8.20.0",
     "@vercel/blob": "^2.4.0",
     "@xyflow/react": "^12.10.2",
+    "ai": "^6.0.193",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "dotenv": "^17.4.2",
@@ -33,11 +38,13 @@
     "prisma": "^7.8.0",
     "react": "19.2.4",
     "react-dom": "19.2.4",
+    "react-markdown": "^10.1.0",
     "tailwind-merge": "^3.6.0",
     "tsx": "^4.22.3"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
+    "@trigger.dev/build": "^4.4.6",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
diff --git a/prisma/migrations/20260528183903_add_task_run/migration.sql b/prisma/migrations/20260528183903_add_task_run/migration.sql
new file mode 100644
index 0000000..dae0319
--- /dev/null
+++ b/prisma/migrations/20260528183903_add_task_run/migration.sql
@@ -0,0 +1,15 @@
+-- CreateTable
+CREATE TABLE "TaskRun" (
+    "runId" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "userId" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "TaskRun_pkey" PRIMARY KEY ("runId")
+);
+
+-- CreateIndex
+CREATE INDEX "TaskRun_runId_idx" ON "TaskRun"("runId");
+
+-- CreateIndex
+CREATE INDEX "TaskRun_userId_projectId_idx" ON "TaskRun"("userId", "projectId");
diff --git a/prisma/migrations/20260618230810_add_project_spec/migration.sql b/prisma/migrations/20260618230810_add_project_spec/migration.sql
new file mode 100644
index 0000000..26b2b14
--- /dev/null
+++ b/prisma/migrations/20260618230810_add_project_spec/migration.sql
@@ -0,0 +1,18 @@
+-- DropIndex
+DROP INDEX "TaskRun_runId_idx";
+
+-- CreateTable
+CREATE TABLE "ProjectSpec" (
+    "id" TEXT NOT NULL,
+    "projectId" TEXT NOT NULL,
+    "filePath" TEXT NOT NULL,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "ProjectSpec_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE INDEX "ProjectSpec_projectId_createdAt_idx" ON "ProjectSpec"("projectId", "createdAt");
+
+-- AddForeignKey
+ALTER TABLE "ProjectSpec" ADD CONSTRAINT "ProjectSpec_projectId_fkey" FOREIGN KEY ("projectId") REFERENCES "Project"("id") ON DELETE CASCADE ON UPDATE CASCADE;
diff --git a/prisma/migrations/20260618230953_make_spec_file_path_optional/migration.sql b/prisma/migrations/20260618230953_make_spec_file_path_optional/migration.sql
new file mode 100644
index 0000000..5805958
--- /dev/null
+++ b/prisma/migrations/20260618230953_make_spec_file_path_optional/migration.sql
@@ -0,0 +1,2 @@
+-- AlterTable
+ALTER TABLE "ProjectSpec" ALTER COLUMN "filePath" DROP NOT NULL;
diff --git a/prisma/models/project.prisma b/prisma/models/project.prisma
index e432f1a..28eb4a8 100644
--- a/prisma/models/project.prisma
+++ b/prisma/models/project.prisma
@@ -14,6 +14,7 @@ model Project {
   updatedAt       DateTime @updatedAt
 
   collaborators   ProjectCollaborator[]
+  specs           ProjectSpec[]
 
   @@index([ownerId])
   @@index([createdAt])
diff --git a/prisma/models/spec.prisma b/prisma/models/spec.prisma
new file mode 100644
index 0000000..2a2b554
--- /dev/null
+++ b/prisma/models/spec.prisma
@@ -0,0 +1,10 @@
+model ProjectSpec {
+  id        String   @id @default(cuid())
+  projectId String
+  filePath  String?
+  createdAt DateTime @default(now())
+
+  project   Project  @relation(fields: [projectId], references: [id], onDelete: Cascade)
+
+  @@index([projectId, createdAt])
+}
diff --git a/prisma/models/task-run.prisma b/prisma/models/task-run.prisma
new file mode 100644
index 0000000..62c1d27
--- /dev/null
+++ b/prisma/models/task-run.prisma
@@ -0,0 +1,8 @@
+model TaskRun {
+  runId     String   @id
+  projectId String
+  userId    String
+  createdAt DateTime @default(now())
+
+  @@index([userId, projectId])
+}
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index 1c8d1ab..a0ec33e 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -6,3 +6,7 @@ generator client {
 datasource db {
   provider = "postgresql"
 }
+
+/// <reference path="./models/project.prisma" />
+/// <reference path="./models/task-run.prisma" />
+/// <reference path="./models/spec.prisma" />
diff --git a/skills-lock.json b/skills-lock.json
index acd9fdb..606c5b5 100644
--- a/skills-lock.json
+++ b/skills-lock.json
@@ -54,6 +54,42 @@
       "sourceType": "github",
       "skillPath": "prisma-upgrade-v7/SKILL.md",
       "computedHash": "2e4d54a4c7a0fc2476e81686718a765f5eb2cacfb2fb0822f3109c76bf4a9bb0"
+    },
+    "trigger-agents": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-agents/SKILL.md",
+      "computedHash": "e3e1d05b7589aba63215ce17a002217547f918da16984099bf924cdc4d8a8a61"
+    },
+    "trigger-config": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-config/SKILL.md",
+      "computedHash": "c7422cc5945fb6f0ffc4bea6588bd8c4822ac93c9dbeefb0072a338a7ae2cd06"
+    },
+    "trigger-cost-savings": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-cost-savings/SKILL.md",
+      "computedHash": "4d41360e1f7544c1c28c4e097e72243bd8b88a9c8d91a37974a75f683c1bace1"
+    },
+    "trigger-realtime": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-realtime/SKILL.md",
+      "computedHash": "0642d7abbd2036e6258ee7fa1050c43e9120faaaf331f79c25aaa7f40bf4cf40"
+    },
+    "trigger-setup": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-setup/SKILL.md",
+      "computedHash": "e6bea732fe6c8da34bd23e57d28351cc55e648039d28a10960306a06c68a6139"
+    },
+    "trigger-tasks": {
+      "source": "triggerdotdev/skills",
+      "sourceType": "github",
+      "skillPath": "trigger-tasks/SKILL.md",
+      "computedHash": "1f65ede75b8118f3b301ac41836b447808a6e188dbce44e2ed8cc161fb6a8b25"
     }
   }
 }
diff --git a/src/.gitignore b/src/.gitignore
new file mode 100644
index 0000000..6524f04
--- /dev/null
+++ b/src/.gitignore
@@ -0,0 +1 @@
+.trigger
\ No newline at end of file
diff --git a/trigger.config.ts b/trigger.config.ts
new file mode 100644
index 0000000..8042089
--- /dev/null
+++ b/trigger.config.ts
@@ -0,0 +1,15 @@
+import { defineConfig } from "@trigger.dev/sdk/v3";
+
+export default defineConfig({
+  project: "proj_skikjlhotmuecbkdjjyg",
+  runtime: "node",
+  logLevel: "log",
+  // The max compute seconds a task is allowed to run. If the task run exceeds this duration, it will be stopped.
+  // You can override this on an individual task.
+  // See https://trigger.dev/docs/runs/max-duration
+  maxDuration: 3600,
+  retries: {
+    enabledInDev: true,
+  },
+  dirs: ["./trigger"],
+});
diff --git a/trigger/design-agent.ts b/trigger/design-agent.ts
new file mode 100644
index 0000000..db8bedc
--- /dev/null
+++ b/trigger/design-agent.ts
@@ -0,0 +1,223 @@
+import { task, logger } from "@trigger.dev/sdk/v3";
+import { generateText, Output } from "ai";
+import { google } from "@ai-sdk/google";
+import { z } from "zod";
+import { Liveblocks } from "@liveblocks/node";
+import { mutateFlow } from "@liveblocks/react-flow/node";
+
+const LIVEBLOCKS_API = "https://api.liveblocks.io/v2";
+const AGENT_USER_ID = "ai-design-agent";
+
+function liveblocksSecret(): string {
+  const key = process.env.LIVEBLOCKS_SECRET_KEY;
+  if (!key) throw new Error("LIVEBLOCKS_SECRET_KEY is not set");
+  return key;
+}
+
+let liveblocksInstance: Liveblocks | null = null;
+function getLiveblocks(): Liveblocks {
+  if (!liveblocksInstance) {
+    liveblocksInstance = new Liveblocks({ secret: liveblocksSecret() });
+  }
+  return liveblocksInstance;
+}
+
+function lbHeaders() {
+  return {
+    Authorization: `Bearer ${liveblocksSecret()}`,
+    "Content-Type": "application/json",
+  };
+}
+
+async function setAiPresence(roomId: string, status: string, ttl = 120) {
+  await fetch(`${LIVEBLOCKS_API}/rooms/${roomId}/presence`, {
+    method: "POST",
+    headers: lbHeaders(),
+    body: JSON.stringify({
+      userId: AGENT_USER_ID,
+      data: { status, cursor: null, isThinking: status !== "complete" },
+      userInfo: {
+        name: "AI Architect",
+        avatar: "",
+        color: "#6457f9",
+      },
+      ttl,
+    }),
+  }).catch((e) => logger.warn("Presence update failed", { error: String(e) }));
+}
+
+const CanvasNodeSchema = z.object({
+  id: z.string().min(1),
+  type: z.literal("canvasNode"),
+  position: z.object({ x: z.number(), y: z.number() }),
+  data: z.object({
+    label: z.string(),
+    color: z.string(),
+    textColor: z.string(),
+    shape: z.enum([
+      "rectangle",
+      "diamond",
+      "circle",
+      "pill",
+      "cylinder",
+      "hexagon",
+    ]),
+  }),
+  width: z.number().optional().default(150),
+  height: z.number().optional().default(60),
+});
+
+const CanvasEdgeSchema = z.object({
+  id: z.string().min(1),
+  source: z.string().min(1),
+  target: z.string().min(1),
+  type: z.literal("canvasEdge"),
+  data: z
+    .object({
+      label: z.string().optional(),
+    })
+    .optional()
+    .default({}),
+});
+
+const DesignSchema = z.object({
+  nodes: z.array(CanvasNodeSchema),
+  edges: z.array(CanvasEdgeSchema),
+}).refine(
+  (data) => {
+    // Allow empty edges only if there's 0 or 1 node
+    if (data.edges.length === 0 && data.nodes.length > 1) {
+      return false;
+    }
+    return true;
+  },
+  {
+    message: "Designs with multiple nodes must include edges connecting them",
+    path: ["edges"],
+  }
+);
+
+export const designAgent = task({
+  id: "design-agent",
+  run: async (payload: {
+    prompt: string;
+    roomId: string;
+    projectId: string;
+    userId: string;
+  }) => {
+    const { prompt, roomId } = payload;
+
+    if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY && process.env.GOOGLE_AI_API_KEY) {
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY = process.env.GOOGLE_AI_API_KEY;
+    }
+
+    await setAiPresence(roomId, "Analyzing your prompt…");
+
+    const result = await generateText({
+      model: google("gemini-2.5-flash"),
+      output: Output.object({
+        name: "Design",
+        schema: DesignSchema,
+      }),
+      system: [
+        "You are an AI system designer that generates node-and-edge diagrams for a collaborative canvas.",
+        "",
+        "CRITICAL INSTRUCTION: Every design with more than one node MUST include edges connecting them. A diagram is useless without connections — nodes alone do not describe an architecture. Always include edges unless the design has exactly one node.",
+        "",
+        "=== EDGE RULES ===",
+        '- type MUST be "canvasEdge"',
+        "- source and target MUST be valid node IDs from your nodes array",
+        "- Each edge needs a unique id (e.g. \"e1\", \"e2\")",
+        "- data.label is optional but recommended to describe the relationship (e.g. \"HTTP\", \"gRPC\", \"events\", \"SQL\", \"pub/sub\")",
+        "- Every pair of nodes that logically communicate or depend on each other MUST be connected by an edge",
+        "- Do NOT produce disconnected node clusters — every node should be reachable from others via edges",
+        "",
+        "=== CORRECT EXAMPLE ===",
+        'Input: "design a microservice architecture with api gateway, auth, and database"',
+        "Output:",
+        '{',
+        '  "nodes": [',
+        '    { "id": "api-gateway", "type": "canvasNode", "position": { "x": 0, "y": 50 }, "data": { "label": "API Gateway", "color": "#10233D", "textColor": "#52A8FF", "shape": "pill" }, "width": 150, "height": 60 },',
+        '    { "id": "auth-service", "type": "canvasNode", "position": { "x": 350, "y": 0 }, "data": { "label": "Auth Service", "color": "#0F2E18", "textColor": "#62C073", "shape": "rectangle" }, "width": 150, "height": 60 },',
+        '    { "id": "db", "type": "canvasNode", "position": { "x": 350, "y": 100 }, "data": { "label": "Database", "color": "#331B00", "textColor": "#FF990A", "shape": "cylinder" }, "width": 150, "height": 60 }',
+        '  ],',
+        '  "edges": [',
+        '    { "id": "e1", "source": "api-gateway", "target": "auth-service", "type": "canvasEdge", "data": { "label": "HTTP" } },',
+        '    { "id": "e2", "source": "auth-service", "target": "db", "type": "canvasEdge", "data": { "label": "SQL" } }',
+        '  ]',
+        '}',
+        "In the example above, every node is connected. The edges show clear relationships between components.",
+        "",
+        "=== BAD EXAMPLE (what NOT to do) ===",
+        "If your output has 3+ nodes but edges is empty or omitted, the design is WRONG. Disconnected nodes do not describe a working system.",
+        "",
+        "=== NODE SHAPES ===",
+        "- rectangle — general-purpose node",
+        "- diamond — decision / gateway",
+        "- circle — event / endpoint",
+        "- pill — service / process",
+        "- cylinder — database / storage",
+        "- hexagon — external system / boundary",
+        "",
+        "=== COLORS (fill + text) ===",
+        '- "#1F1F1F" / "#EDEDED" — Neutral dark (default)',
+        '- "#10233D" / "#52A8FF" — Blue',
+        '- "#2E1938" / "#BF7AF0" — Purple',
+        '- "#331B00" / "#FF990A" — Orange',
+        '- "#3C1618" / "#FF6166" — Red',
+        '- "#3A1726" / "#F75F8F" — Pink',
+        '- "#0F2E18" / "#62C073" — Green',
+        '- "#062822" / "#0AC7B4" — Teal',
+        "",
+        "=== LAYOUT RULES ===",
+        "- Place related services close together, separated by ~200px horizontally and ~150px vertically",
+        "- Use left-to-right or top-to-bottom flow direction",
+        "- Add labels that clearly describe each component",
+        "- Use appropriate shapes",
+      ].join("\n"),
+      messages: [
+        {
+          role: "user",
+          content: prompt,
+        },
+      ],
+    });
+
+    const design = result.output;
+
+    logger.info("Design generated", {
+      nodeCount: design.nodes.length,
+      edgeCount: design.edges.length,
+    });
+
+    if (design.nodes.length === 0 && design.edges.length === 0) {
+      await setAiPresence(roomId, "Could not generate a design from that prompt", 10);
+      return { status: "no_design_generated" };
+    }
+
+    await setAiPresence(roomId, "Applying design to canvas…");
+
+    await mutateFlow(
+      {
+        client: getLiveblocks(),
+        roomId,
+        nodes: { sync: { canvasNode: { data: true } } },
+        edges: { sync: { canvasEdge: { data: true } } },
+      },
+      (flow) => {
+        flow.addNodes(design.nodes as any);
+        flow.addEdges(design.edges as any);
+      },
+    );
+
+    await setAiPresence(roomId, "Design applied", 5);
+
+    logger.info("Design generation complete", { roomId });
+
+    return {
+      status: "complete",
+      nodesGenerated: design.nodes.length,
+      edgesGenerated: design.edges.length,
+    };
+  },
+});
diff --git a/trigger/generate-spec.ts b/trigger/generate-spec.ts
new file mode 100644
index 0000000..1e64483
--- /dev/null
+++ b/trigger/generate-spec.ts
@@ -0,0 +1,127 @@
+import { task, logger } from "@trigger.dev/sdk/v3";
+import { generateText } from "ai";
+import { google } from "@ai-sdk/google";
+import { z } from "zod";
+import { put } from "@vercel/blob";
+import { prisma } from "@/lib/prisma";
+
+const ChatMessageSchema = z.object({
+  role: z.string(),
+  content: z.string(),
+});
+
+const InputNodeSchema = z.object({
+  id: z.string(),
+  data: z.object({
+    label: z.string(),
+    shape: z.string().optional(),
+  }).passthrough(),
+  position: z.object({ x: z.number(), y: z.number() }).optional(),
+}).passthrough();
+
+const InputEdgeSchema = z.object({
+  id: z.string(),
+  source: z.string(),
+  target: z.string(),
+  data: z.object({
+    label: z.string().optional(),
+  }).passthrough().optional(),
+}).passthrough();
+
+const SpecInputSchema = z.object({
+  projectId: z.string().min(1),
+  roomId: z.string().min(1),
+  chatHistory: z.array(ChatMessageSchema).default([]),
+  nodes: z.array(InputNodeSchema).default([]),
+  edges: z.array(InputEdgeSchema).default([]),
+});
+
+export const generateSpec = task({
+  id: "generate-spec",
+  run: async (payload: z.infer<typeof SpecInputSchema>) => {
+    const parsed = SpecInputSchema.parse(payload);
+    const { nodes, edges, chatHistory } = parsed;
+
+    if (!process.env.GOOGLE_GENERATIVE_AI_API_KEY && process.env.GOOGLE_AI_API_KEY) {
+      process.env.GOOGLE_GENERATIVE_AI_API_KEY = process.env.GOOGLE_AI_API_KEY;
+    }
+
+    logger.info("Generating spec", {
+      nodeCount: nodes.length,
+      edgeCount: edges.length,
+      chatLength: chatHistory.length,
+    });
+
+    const nodeDescriptions = nodes.map((n) => {
+      const shape = n.data.shape ?? "rectangle";
+      return `- ${n.id}: "${n.data.label}" (${shape}) at (${n.position?.x ?? 0}, ${n.position?.y ?? 0})`;
+    }).join("\n");
+
+    const edgeDescriptions = edges.map((e) => {
+      const label = e.data?.label ? ` [${e.data.label}]` : "";
+      return `- ${e.source} → ${e.target}${label}`;
+    }).join("\n");
+
+    const chatContext = chatHistory.length > 0
+      ? `\n\n## Chat History\n\n${chatHistory.map((m) => `**${m.role}**: ${m.content}`).join("\n")}`
+      : "";
+
+    const systemPrompt = [
+      "You are a technical spec writer. Given a system architecture diagram and optional chat context, produce a complete technical specification in Markdown.",
+      "",
+      "Include the following sections where applicable:",
+      "1. **Overview** — what this system does",
+      "2. **Architecture** — describe each component's role using the diagram labels",
+      "3. **Data Flow** — describe how data moves between components based on edges",
+      "4. **Key Design Decisions** — infer architectural choices from the topology",
+      "5. **Recommendations** — suggest improvements or considerations",
+      "",
+      "Format the output as clean, well-structured Markdown. Use proper headings, lists, and code blocks where appropriate.",
+      "Do not include a preamble or conclusion outside the spec structure.",
+    ].join("\n");
+
+    const userPrompt = [
+      "Generate a technical specification for the system described below.",
+      "",
+      "## Diagram Nodes",
+      nodeDescriptions || "(no nodes defined)",
+      "",
+      "## Diagram Edges",
+      edgeDescriptions || "(no edges defined)",
+      chatContext,
+    ].join("\n");
+
+    const result = await generateText({
+      model: google("gemini-2.5-flash"),
+      system: systemPrompt,
+      messages: [{ role: "user", content: userPrompt }],
+    });
+
+    const spec = result.text;
+
+    const specRecord = await prisma.projectSpec.create({
+      data: {
+        projectId: parsed.projectId,
+      },
+    });
+
+    const blobPath = `specs/${parsed.projectId}/${specRecord.id}.md`;
+    const blob = await put(blobPath, spec, {
+      contentType: "text/markdown",
+      access: "private",
+    });
+
+    await prisma.projectSpec.update({
+      where: { id: specRecord.id },
+      data: { filePath: blob.url },
+    });
+
+    logger.info("Spec generation complete", {
+      length: spec.length,
+      roomId: parsed.roomId,
+      specId: specRecord.id,
+    });
+
+    return { spec, specId: specRecord.id, blobUrl: blob.url, status: "complete" };
+  },
+});
diff --git a/tsconfig.json b/tsconfig.json
index 3a13f90..dc6f74a 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -28,7 +28,8 @@
     "**/*.tsx",
     ".next/types/**/*.ts",
     ".next/dev/types/**/*.ts",
-    "**/*.mts"
+    "**/*.mts",
+    "trigger.config.ts"
   ],
   "exclude": ["node_modules"]
 }
diff --git a/types/canvas.ts b/types/canvas.ts
index 27ae73c..81fcd11 100644
--- a/types/canvas.ts
+++ b/types/canvas.ts
@@ -26,5 +26,9 @@ export interface CanvasEdgeData {
   [key: string]: unknown
 }
 
+export interface AiStatusPayload {
+  text?: string
+}
+
 export type CanvasNode = Node<CanvasNodeData, "canvasNode">
 export type CanvasEdge = Edge<CanvasEdgeData, "canvasEdge">
diff --git a/types/task.ts b/types/task.ts
new file mode 100644
index 0000000..3547338
--- /dev/null
+++ b/types/task.ts
@@ -0,0 +1,16 @@
+import { z } from "zod"
+
+export const AiStatusSchema = z.object({
+  text: z.string().optional(),
+})
+
+export type AiStatus = z.infer<typeof AiStatusSchema>
+
+export const AiChatMessageSchema = z.object({
+  sender: z.string().min(1),
+  role: z.enum(["user", "assistant"]),
+  content: z.string().min(1),
+  timestamp: z.number(),
+})
+
+export type AiChatMessage = z.infer<typeof AiChatMessageSchema>