@aion0/forge 0.4.16 → 0.5.1

package/README.md

@@ -1,5 +1,5 @@
 <p align="center">
-  <img src="app/icon.svg" width="80" height="80" alt="Forge">
+  <img src="app/icon.ico" width="80" height="80" alt="Forge">
 </p>
 
 <h1 align="center">Forge</h1>
@@ -49,11 +49,36 @@ Forge turns Claude Code into a remote-accessible coding platform. Run it on your
 
 No API keys required. Uses your existing Claude Code subscription. Code never leaves your machine.
 
+## Multi-Agent Workspace <sup>v0.5.0</sup>
+
+Define agent teams with roles, dependencies, and steps. Agents run as daemons and communicate via a structured message bus.
+
+```mermaid
+graph LR
+    Input["📋 Requirements"] --> PM["🎯 PM"]
+    PM --> Eng["🔨 Engineer"]
+    Eng --> QA["🧪 QA"]
+    Eng --> Rev["👁 Reviewer"]
+    QA --> Rev
+
+    style Input fill:#f0883e,stroke:#f0883e,color:#fff
+    style PM fill:#a371f7,stroke:#a371f7,color:#fff
+    style Eng fill:#58a6ff,stroke:#58a6ff,color:#fff
+    style QA fill:#3fb950,stroke:#3fb950,color:#fff
+    style Rev fill:#f778ba,stroke:#f778ba,color:#fff
+```
+
+- **Agent profiles** — Reusable configs with env vars, model overrides, custom API endpoints (Claude, Codex, Aider)
+- **Message system** — Notifications (follow DAG) + Tickets (any direction, retry limits) with causedBy tracing
+- **Manual mode** — Open a terminal on any agent, work interactively, return to auto
+- **Watch manager** — Monitor files, git, or commands. Auto-analyze or require approval on changes
+
 ## Features
 
 | | |
 |---|---|
-| **Vibe Coding** | Browser tmux terminal, multi-tab, split panes, persistent sessions |
+| **Multi-Agent Workspace** | Agent teams with DAG dependencies, message bus, watch monitoring, manual/auto mode |
+| **Vibe Coding** | Browser tmux terminal, multi-tab, split panes, WebGL, Ctrl+F search |
 | **AI Tasks** | Background Claude Code execution with live streaming output |
 | **Pipelines** | YAML DAG workflows with parallel execution & visual editor |
 | **Remote Access** | Cloudflare Tunnel with 2FA (password + session code) |

package/RELEASE_NOTES.md

@@ -1,26 +1,33 @@
-# Forge v0.4.16
+# Forge v0.5.1
 
-Released: 2026-03-23
+Released: 2026-03-28
 
-## Changes since v0.4.15
+## Changes since v0.5.0
 
 ### Features
-- feat: change default port from 3000/3001 to 8403/8404
-- feat: prompt to restart Claude after skill/command installation
-- Revert "feat: mobile real-time streaming with tool activity display"
-- feat: mobile real-time streaming with tool activity display
+- feat: daemon health check + SSE for all message actions
+- feat: pending_approval status for watch approve + requiresApproval
 
 ### Bug Fixes
-- fix: only show port change warning when using default port
-- fix: upgrade Next.js 16.1.6 → 16.2.1 to fix Turbopack panic
-- fix: start.sh exports PORT=8403 and TERMINAL_PORT=8404
-- fix: default config port 3000 → 8403
+- fix: stop old worker before creating new one in enterDaemonListening
+- fix: prevent multiple running messages + clean stale running
+- fix: requiresApproval set at message arrival, not in message loop
+- fix: approved messages not re-converted to pending_approval
+- fix: message loop never stops + auto-recreate dead workers
+- fix: approve/reject emit SSE events + reject marks as failed
+- fix: emit bus_message_status after watch approve sets pending_approval
+- fix: pending_approval edge cases
+- fix: system messages (_watch, _system, user) bypass causedBy rules
 
 ### Documentation
-- docs: update README port 3000 → 8403
+- docs: add workspace section + agent flow diagram to README
+- docs: README with Mermaid diagrams for v0.5.0
+- docs: update README for v0.5.0 — multi-agent workspace
+- docs: update workspace help with watch, logs, forge skills, send protection
 
 ### Other
-- Revert "feat: mobile real-time streaming with tool activity display"
+- ui: add requiresApproval toggle in agent config modal
+- debug: log watch analyze skip reasons
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.4.15...v0.4.16
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.5.0...v0.5.1

package/app/api/agents/route.ts

@@ -0,0 +1,17 @@
+import { NextResponse } from 'next/server';
+import { listAgents, getDefaultAgentId, resolveTerminalLaunch } from '@/lib/agents';
+
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const resolve = url.searchParams.get('resolve');
+
+  // GET /api/agents?resolve=claude → resolve terminal launch info for an agent
+  if (resolve) {
+    const info = resolveTerminalLaunch(resolve);
+    return NextResponse.json(info);
+  }
+
+  const agents = listAgents();
+  const defaultAgent = getDefaultAgentId();
+  return NextResponse.json({ agents, defaultAgent });
+}

package/app/api/delivery/[id]/route.ts

@@ -0,0 +1,62 @@
+import { NextResponse } from 'next/server';
+import {
+  getDelivery, cancelDelivery, deleteDelivery,
+  approveDeliveryPhase, rejectDeliveryPhase,
+  sendToAgent, retryPhase,
+} from '@/lib/delivery';
+import { listArtifacts, getArtifact } from '@/lib/artifacts';
+import type { PhaseName } from '@/lib/delivery';
+
+// GET /api/delivery/:id — get delivery state + artifacts
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const delivery = getDelivery(id);
+  if (!delivery) return NextResponse.json({ error: 'Not found' }, { status: 404 });
+
+  const artifacts = listArtifacts(id);
+  return NextResponse.json({ ...delivery, artifacts });
+}
+
+// POST /api/delivery/:id — actions
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+  const { action } = body;
+
+  if (action === 'cancel') {
+    return NextResponse.json({ ok: cancelDelivery(id) });
+  }
+
+  if (action === 'delete') {
+    return NextResponse.json({ ok: deleteDelivery(id) });
+  }
+
+  if (action === 'approve') {
+    return NextResponse.json({ ok: approveDeliveryPhase(id, body.feedback) });
+  }
+
+  if (action === 'reject') {
+    if (!body.feedback) return NextResponse.json({ error: 'feedback required' }, { status: 400 });
+    return NextResponse.json({ ok: rejectDeliveryPhase(id, body.feedback) });
+  }
+
+  if (action === 'send') {
+    const { phase, message } = body;
+    if (!phase || !message) return NextResponse.json({ error: 'phase and message required' }, { status: 400 });
+    return NextResponse.json({ ok: sendToAgent(id, phase as PhaseName, message) });
+  }
+
+  if (action === 'retry') {
+    const { phase } = body;
+    if (!phase) return NextResponse.json({ error: 'phase required' }, { status: 400 });
+    return NextResponse.json({ ok: retryPhase(id, phase as PhaseName) });
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
+}
+
+// DELETE /api/delivery/:id
+export async function DELETE(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  return NextResponse.json({ ok: deleteDelivery(id) });
+}

package/app/api/delivery/route.ts

@@ -0,0 +1,40 @@
+import { NextResponse } from 'next/server';
+import { createDelivery, listDeliveries, ROLE_PRESETS } from '@/lib/delivery';
+
+// GET /api/delivery — list deliveries, or get role presets
+export async function GET(req: Request) {
+  const { searchParams } = new URL(req.url);
+
+  if (searchParams.get('type') === 'presets') {
+    return NextResponse.json(ROLE_PRESETS);
+  }
+
+  const deliveries = listDeliveries();
+  return NextResponse.json(deliveries);
+}
+
+// POST /api/delivery — create new delivery
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { title, project, projectPath, prUrl, description, agentId, phases } = body;
+
+  if (!project || !projectPath) {
+    return NextResponse.json({ error: 'project and projectPath required' }, { status: 400 });
+  }
+
+  try {
+    const delivery = createDelivery({
+      title: title || description?.slice(0, 50) || 'Delivery',
+      project,
+      projectPath,
+      prUrl,
+      description,
+      agentId,
+      customPhases: phases,  // user-defined phases
+    });
+
+    return NextResponse.json(delivery);
+  } catch (e: any) {
+    return NextResponse.json({ error: e.message }, { status: 500 });
+  }
+}

package/app/api/mobile-chat/route.ts

@@ -7,26 +7,32 @@ export const runtime = 'nodejs';
 
 // POST /api/mobile-chat — send a message to claude and stream response
 export async function POST(req: Request) {
-  const { message, projectPath, resume } = await req.json() as {
+  const { message, projectPath, resume, agent: agentId } = await req.json() as {
     message: string;
     projectPath: string;
     resume?: boolean;
+    agent?: string;
   };
 
   if (!message || !projectPath) {
     return NextResponse.json({ error: 'message and projectPath required' }, { status: 400 });
   }
 
-  const settings = loadSettings();
-  const claudePath = settings.claudePath || 'claude';
+  const { getAgent } = require('@/lib/agents');
+  const adapter = getAgent(agentId);
   const projectName = projectPath.split('/').pop() || projectPath;
 
-  const args = ['-p', '--dangerously-skip-permissions', '--output-format', 'json'];
-  if (resume) args.push('-c');
+  const spawnOpts = adapter.buildTaskSpawn({
+    projectPath,
+    prompt: message,
+    skipPermissions: true,
+    outputFormat: adapter.config.capabilities?.supportsStreamJson ? 'json' : undefined,
+    conversationId: resume ? 'last' : undefined,
+  });
 
-  const child = spawn(claudePath, args, {
+  const child = spawn(spawnOpts.cmd, spawnOpts.args, {
     cwd: projectPath,
-    env: { ...process.env },
+    env: { ...process.env, ...(spawnOpts.env || {}) },
     stdio: ['pipe', 'pipe', 'pipe'],
   });
 

package/app/api/monitor/route.ts

@@ -7,11 +7,13 @@ function run(cmd: string): string {
   } catch { return ''; }
 }
 
-function countProcess(pattern: string): { count: number; pid: string } {
+function countProcess(pattern: string): { count: number; pid: string; startedAt: string } {
   const out = run(`ps aux | grep '${pattern}' | grep -v grep | head -1`);
   const pid = out ? out.split(/\s+/)[1] || '' : '';
   const count = out ? run(`ps aux | grep '${pattern}' | grep -v grep | wc -l`).trim() : '0';
-  return { count: parseInt(count), pid };
+  // Get start time from ps
+  const startedAt = pid ? run(`ps -o lstart= -p ${pid} 2>/dev/null`).trim() : '';
+  return { count: parseInt(count), pid, startedAt };
 }
 
 export async function GET() {
@@ -19,6 +21,7 @@ export async function GET() {
   const nextjs = countProcess('next-server');
   const terminal = countProcess('terminal-standalone');
   const telegram = countProcess('telegram-standalone');
+  const workspace = countProcess('workspace-standalone');
   const tunnel = countProcess('cloudflared tunnel');
 
   // Tunnel URL
@@ -47,10 +50,11 @@ export async function GET() {
 
   return NextResponse.json({
     processes: {
-      nextjs: { running: nextjs.count > 0, pid: nextjs.pid },
-      terminal: { running: terminal.count > 0, pid: terminal.pid },
-      telegram: { running: telegram.count > 0, pid: telegram.pid },
-      tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl },
+      nextjs: { running: nextjs.count > 0, pid: nextjs.pid, startedAt: nextjs.startedAt },
+      terminal: { running: terminal.count > 0, pid: terminal.pid, startedAt: terminal.startedAt },
+      telegram: { running: telegram.count > 0, pid: telegram.pid, startedAt: telegram.startedAt },
+      workspace: { running: workspace.count > 0, pid: workspace.pid, startedAt: workspace.startedAt },
+      tunnel: { running: tunnel.count > 0, pid: tunnel.pid, url: tunnelUrl, startedAt: tunnel.startedAt },
     },
     sessions,
     uptime: uptime.replace(/.*up\s+/, '').replace(/,\s+\d+ user.*/, '').trim(),

package/app/api/pipelines/[id]/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from 'next/server';
-import { getPipeline, cancelPipeline, deletePipeline } from '@/lib/pipeline';
+import { getPipeline, cancelPipeline, deletePipeline, injectConversationMessage } from '@/lib/pipeline';
 
 // GET /api/pipelines/:id
 export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
@@ -9,10 +9,11 @@ export async function GET(_req: Request, { params }: { params: Promise<{ id: str
   return NextResponse.json(pipeline);
 }
 
-// POST /api/pipelines/:id — actions (cancel)
+// POST /api/pipelines/:id — actions (cancel, delete, inject)
 export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
-  const { action } = await req.json();
+  const body = await req.json();
+  const { action } = body;
 
   if (action === 'cancel') {
     const ok = cancelPipeline(id);
@@ -24,5 +25,17 @@ export async function POST(req: Request, { params }: { params: Promise<{ id: str
     return NextResponse.json({ ok });
   }
 
+  // Inject a message into a running conversation
+  if (action === 'inject') {
+    const { agentId, message } = body;
+    if (!agentId || !message) return NextResponse.json({ error: 'agentId and message required' }, { status: 400 });
+    try {
+      const ok = injectConversationMessage(id, agentId, message);
+      return NextResponse.json({ ok });
+    } catch (e: any) {
+      return NextResponse.json({ error: e.message }, { status: 400 });
+    }
+  }
+
   return NextResponse.json({ error: 'Unknown action' }, { status: 400 });
 }

package/app/api/tasks/route.ts

@@ -14,7 +14,7 @@ export async function GET(req: Request) {
 
 // Create a new task
 export async function POST(req: Request) {
-  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig } = await req.json();
+  const { projectName, prompt, priority, newSession, conversationId, scheduledAt, mode, watchConfig, agent } = await req.json();
 
   if (!projectName || !prompt) {
     return NextResponse.json({ error: 'projectName and prompt are required' }, { status: 400 });
@@ -37,6 +37,7 @@ export async function POST(req: Request) {
     scheduledAt: scheduledAt || undefined,
     mode: mode || 'prompt',
     watchConfig: watchConfig || undefined,
+    agent: agent || undefined,
   });
 
   return NextResponse.json(task);

package/app/api/workspace/[id]/agents/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Agent operations
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}
+
+// Proxy to workspace daemon — Get agent states
+export async function GET(_req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/agents`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/memory/route.ts

@@ -0,0 +1,23 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Memory query
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id: workspaceId } = await params;
+  const url = new URL(req.url);
+  const agentId = url.searchParams.get('agentId');
+
+  if (!agentId) {
+    return NextResponse.json({ error: 'agentId required' }, { status: 400 });
+  }
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${workspaceId}/memory?agentId=${encodeURIComponent(agentId)}`);
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/smith/route.ts

@@ -0,0 +1,22 @@
+import { NextResponse } from 'next/server';
+
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// Proxy to workspace daemon — Smith API (called by forge skills in terminal)
+export async function POST(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+  const body = await req.json();
+
+  try {
+    const res = await fetch(`${DAEMON_URL}/workspace/${id}/smith`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    });
+    const data = await res.json();
+    return NextResponse.json(data, { status: res.status });
+  } catch (err: any) {
+    return NextResponse.json({ error: 'Workspace daemon not available' }, { status: 503 });
+  }
+}

package/app/api/workspace/[id]/stream/route.ts

@@ -0,0 +1,28 @@
+const WORKSPACE_PORT = Number(process.env.WORKSPACE_PORT) || 8405;
+const DAEMON_URL = `http://localhost:${WORKSPACE_PORT}`;
+
+// SSE relay — proxy daemon's SSE stream to browser
+export async function GET(req: Request, { params }: { params: Promise<{ id: string }> }) {
+  const { id } = await params;
+
+  try {
+    const daemonRes = await fetch(`${DAEMON_URL}/workspace/${id}/stream`, {
+      signal: req.signal,
+    });
+
+    if (!daemonRes.ok || !daemonRes.body) {
+      return new Response(daemonRes.statusText || 'Daemon error', { status: daemonRes.status });
+    }
+
+    // Pipe daemon SSE stream directly to browser
+    return new Response(daemonRes.body, {
+      headers: {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache, no-transform',
+        'Connection': 'keep-alive',
+      },
+    });
+  } catch (err: any) {
+    return new Response('Workspace daemon not available', { status: 503 });
+  }
+}

package/app/api/workspace/route.ts

@@ -0,0 +1,100 @@
+import { NextResponse } from 'next/server';
+import { listWorkspaces, findWorkspaceByProject, loadWorkspace, saveWorkspace, deleteWorkspace } from '@/lib/workspace';
+import type { WorkspaceState } from '@/lib/workspace';
+import { randomUUID } from 'node:crypto';
+
+// List workspaces, find by projectPath, or export template
+export async function GET(req: Request) {
+  const url = new URL(req.url);
+  const projectPath = url.searchParams.get('projectPath');
+  const exportId = url.searchParams.get('export');
+
+  if (exportId) {
+    // Export workspace as template (agents + positions, no state/logs)
+    const ws = loadWorkspace(exportId);
+    if (!ws) return NextResponse.json({ error: 'not found' }, { status: 404 });
+    const template = {
+      name: ws.projectName + ' template',
+      agents: ws.agents.map(a => ({ ...a, entries: undefined })),  // strip Input entries
+      nodePositions: ws.nodePositions,
+      exportedAt: Date.now(),
+    };
+    return NextResponse.json(template);
+  }
+
+  if (projectPath) {
+    const ws = findWorkspaceByProject(projectPath);
+    return NextResponse.json(ws || null);
+  }
+
+  return NextResponse.json(listWorkspaces());
+}
+
+// Create workspace or import template
+export async function POST(req: Request) {
+  const body = await req.json();
+  const { projectPath, projectName, template } = body;
+
+  if (!projectPath || !projectName) {
+    return NextResponse.json({ error: 'projectPath and projectName are required' }, { status: 400 });
+  }
+
+  const existing = findWorkspaceByProject(projectPath);
+  if (existing && !template) {
+    return NextResponse.json(existing);
+  }
+
+  const state: WorkspaceState = {
+    id: existing?.id || randomUUID(),
+    projectPath,
+    projectName,
+    agents: [],
+    agentStates: {},
+    nodePositions: {},
+    busLog: [],
+    createdAt: existing?.createdAt || Date.now(),
+    updatedAt: Date.now(),
+  };
+
+  // Import template: create agents from template with new IDs
+  if (template?.agents) {
+    const idMap = new Map<string, string>(); // old ID → new ID
+    const ts = Date.now();
+    for (const agent of template.agents) {
+      const newId = `${agent.label.toLowerCase().replace(/\s+/g, '-')}-${ts}-${Math.random().toString(36).slice(2, 5)}`;
+      idMap.set(agent.id, newId);
+    }
+    for (const agent of template.agents) {
+      state.agents.push({
+        ...agent,
+        id: idMap.get(agent.id) || agent.id,
+        dependsOn: agent.dependsOn.map((d: string) => idMap.get(d) || d),
+        entries: agent.type === 'input' ? [] : undefined,
+      });
+      state.agentStates[idMap.get(agent.id) || agent.id] = { smithStatus: 'down', mode: 'auto', taskStatus: 'idle', history: [], artifacts: [] };
+    }
+    if (template.nodePositions) {
+      for (const [oldId, pos] of Object.entries(template.nodePositions)) {
+        const newId = idMap.get(oldId);
+        if (newId) state.nodePositions[newId] = pos as { x: number; y: number };
+      }
+    }
+  }
+
+  await saveWorkspace(state);
+  return NextResponse.json(state, { status: 201 });
+}
+
+// Delete a workspace
+export async function DELETE(req: Request) {
+  const url = new URL(req.url);
+  const id = url.searchParams.get('id');
+  if (!id) return NextResponse.json({ error: 'id required' }, { status: 400 });
+
+  // Unload from daemon if active
+  const daemonUrl = `http://localhost:${Number(process.env.WORKSPACE_PORT) || 8405}`;
+  try { await fetch(`${daemonUrl}/workspace/${id}/unload`, { method: 'POST' }); } catch {}
+
+  deleteWorkspace(id);
+  return NextResponse.json({ ok: true });
+}

package/app/global-error.tsx

@@ -1,12 +1,18 @@
 'use client';
 
-export default function GlobalError({ error, reset }: { error: Error; reset: () => void }) {
+export default function GlobalError({ error, reset }: { error: Error & { digest?: string }; reset: () => void }) {
   return (
-    <html>
+    <html lang="en">
+      <head>
+        <meta charSet="utf-8" />
+      </head>
       <body style={{ background: '#0a0a0a', color: '#e5e5e5', fontFamily: 'monospace', padding: '2rem' }}>
         <h2>Something went wrong</h2>
-        <p style={{ color: '#999' }}>{error.message}</p>
-        <button onClick={reset} style={{ marginTop: '1rem', padding: '0.5rem 1rem', background: '#3b82f6', color: '#fff', border: 'none', borderRadius: '4px', cursor: 'pointer' }}>
+        <p style={{ color: '#999' }}>{error?.message || 'Unknown error'}</p>
+        <button
+          onClick={() => reset()}
+          style={{ marginTop: '1rem', padding: '0.5rem 1rem', background: '#3b82f6', color: '#fff', border: 'none', borderRadius: '4px', cursor: 'pointer' }}
+        >
           Try again
         </button>
       </body>

package/app/layout.tsx

@@ -8,8 +8,8 @@ export const metadata: Metadata = {
 
 export default function RootLayout({ children }: { children: React.ReactNode }) {
   return (
-    <html lang="en" className="dark">
-      <body className="min-h-screen bg-[var(--bg-primary)]">
+    <html lang="en" className="dark" suppressHydrationWarning>
+      <body className="min-h-screen bg-[var(--bg-primary)]" suppressHydrationWarning>
         {children}
       </body>
     </html>