fix error

.agent/memory/session.json

@@ -1,7 +1,7 @@
 {
   "version": "1.0.0",
-  "session_id": "0885d2be",
-  "started_at": "2026-04-06T17:16:01.973288+05:30",
+  "session_id": "c1981984",
+  "started_at": "2026-04-06T17:31:46.672890+05:30",
   "workspace": "D:\\Code\\codeverse",
   "active_task_id": null,
   "active_agent": null,

Dockerfile

@@ -7,24 +7,29 @@ ENV WORKSPACE_ROOT=/app/workspaces
 ENV ANDROID_SDK_ROOT=/app/android-sdk
 ENV PATH="/home/node/.nix-profile/bin:/usr/local/bin:${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin:${ANDROID_SDK_ROOT}/platform-tools:${PATH}"
 
-# 2. Modern Infrastructure Layer (IDX Studio 2026 Baseline)
+# 2. Modern Infrastructure Layer (Optimized for Hugging Face Spaces)
 RUN apt-get update && apt-get install -y --no-install-recommends \
-    libc6 libstdc++6 python3 make g++ git curl ca-certificates tar unzip \
+    python3 python3-pip make g++ git curl ca-certificates tar unzip bzip2 xz-utils \
     openjdk-17-jdk xvfb fluxbox novnc websockify libnss3 libatk-bridge2.0-0 \
-    libcups2 libgtk-3-0 xz-utils procps bzip2 iptables \
+    libcups2 libgtk-3-0 procps net-tools iptables \
     && rm -rf /var/lib/apt/lists/*
 
-# 3. code-server Modernization (v4.114.0 - Latest 2026 Stable)
+# 3. code-server Modernization (v4.114.0 - Stable 2026)
 RUN curl -fL https://github.com/coder/code-server/releases/download/v4.114.0/code-server-4.114.0-linux-amd64.tar.gz \
     | tar -C /usr/local/lib -xz \
     && ln -s /usr/local/lib/code-server-4.114.0-linux-amd64/bin/code-server /usr/local/bin/code-server
 
-# 4. Determinate Systems Nix Installer (Unprivileged & Hermetic)
+# 4. Determinate Systems Nix Installer (Unprivileged, Single-User)
 RUN curl --proto '=https' --tlsv1.2 -sSf -L https://install.determinate.systems/nix | sh -s -- install linux \
     --init none --no-confirm --extra-conf "experimental-features = nix-command flakes" \
+    --extra-conf "sandbox = false" \
     && chown -R node:node /nix /home/node
 
-# 5. Android SDK (Baseline for Studio Preview)
+# 5. Advanced Acceleration Layer (Cachix & Hugging Face Hub CLI)
+RUN pip3 install --no-cache-dir huggingface-hub --break-system-packages \
+    && curl -fL https://cachix.org/api/v1/install | sh
+
+# 6. Android SDK (Studio Preview Engine Integration)
 WORKDIR /app
 RUN mkdir -p ${ANDROID_SDK_ROOT} && \
     curl -fL https://dl.google.com/android/repository/commandlinetools-linux-9477386_latest.zip -o cmdline.zip && \
@@ -33,24 +38,24 @@ RUN mkdir -p ${ANDROID_SDK_ROOT} && \
     rm cmdline.zip && \
     yes | ${ANDROID_SDK_ROOT}/cmdline-tools/latest/bin/sdkmanager --sdk_root=${ANDROID_SDK_ROOT} "platform-tools" "platforms;android-33"
 
-# 6. CodeVerse Application Layer
+# 7. CodeVerse Application Layer (Strict Production Build)
 WORKDIR /app
 COPY package*.json ./
 RUN npm install
 
 COPY . .
 
-# 7. Final Sanity Check & Build (Strict Targets)
+# 8. Final Sanity Check & Build (Strict Targets)
 RUN npm run build && \
     mkdir -p ${WORKSPACE_ROOT} && \
     chown -R node:node /app ${WORKSPACE_ROOT}
 
-# User context for Hugging Face Spaces (UID 1000)
 USER node
 EXPOSE 7860
 
 # idx-start signal for boot manager
-LABEL org.opencontainers.image.source=https://github.com/shubhjn/codeverse
 LABEL idx.studio.version="2026.04"
+LABEL idx.optimization.cachix="true"
+LABEL idx.optimization.hfsync="true"
 
 CMD ["npm", "run", "start"]

app/api/system/vitals/route.ts

@@ -0,0 +1,37 @@
+import { NextResponse } from 'next/server';
+import os from 'os';
+
+/**
+ * Infrastructure Health & Vitals API.
+ * Provides real-time metrics for Hugging Face Spaces monitoring.
+ */
+export async function GET() {
+    const memory = process.memoryUsage();
+    const systemMemory = {
+        free: os.freemem(),
+        total: os.totalmem(),
+    };
+
+    const uptime = process.uptime();
+    const load = os.loadavg();
+
+    return NextResponse.json({
+        success: true,
+        vitals: {
+            process: {
+                rss: (memory.rss / 1024 / 1024).toFixed(2), // MB
+                heapUsed: (memory.heapUsed / 1024 / 1024).toFixed(2), // MB
+                heapTotal: (memory.heapTotal / 1024 / 1024).toFixed(2), // MB
+            },
+            system: {
+                freeMB: (systemMemory.free / 1024 / 1024).toFixed(0),
+                totalMB: (systemMemory.total / 1024 / 1024).toFixed(0),
+                loadAverage: load[0].toFixed(2),
+            },
+            status: {
+                uptime: `${Math.floor(uptime / 3600)}h ${Math.floor((uptime % 3600) / 60)}m`,
+                nodeVersion: process.version,
+            }
+        }
+    });
+}

app/api/workspace/route.ts

@@ -1,5 +1,5 @@
 import { NextResponse } from "next/server";
-import { startWorkspaceContainer, stopWorkspaceContainer } from "@/lib/docker/manager";
+import { startWorkspaceContainer, stopWorkspaceContainer, prewarmWorkspace } from "@/lib/docker/manager";
 import { auth } from "@/auth";
 import { db } from "@/lib/db";
 
@@ -107,6 +107,10 @@ export async function POST(req: Request) {
                 });
             }
             return NextResponse.json(result);
+        } else if (action === "prewarm") {
+            // FIRE AND FORGET: Hydrate the Nix store and Android SDKs
+            prewarmWorkspace({ id, userId: session.user.id, projectName }).catch(console.error);
+            return NextResponse.json({ success: true, status: 'hydrating' });
         }
 
         return NextResponse.json({ error: "Invalid action" }, { status: 400 });

app/dashboard/booting/BootSequenceClient.tsx

@@ -115,10 +115,12 @@ export default function BootSequenceClient() {
                             <span className="text-blue-400/80">{log}</span>
                         ) : log.startsWith("[IDX:NIX]") ? (
                             <span className="text-purple-400/80">{log}</span>
+                        ) : log.startsWith("[HF:STORAGE]") ? (
+                            <span className="text-cyan-400/80">{log}</span>
                         ) : log.startsWith("[IDX:HOOK]") ? (
                             <span className="text-amber-400/80">{log}</span>
-                        ) : log.startsWith("[IDX:UP]") ? (
-                            <span className="text-zinc-400">{log}</span>
+                        ) : log.startsWith("[IDX:UP]") || log.includes("Cachix") ? (
+                            <span className="text-zinc-400 font-medium italic">{log}</span>
                         ) : (
                             <span className="text-zinc-600">{log}</span>
                         )}

components/DashboardVitals.tsx

@@ -0,0 +1,87 @@
+"use client";
+
+import { useEffect, useState } from "react";
+import { Activity, Cpu, Database, Server } from "lucide-react";
+
+interface VitalsData {
+    process: {
+        rss: string;
+        heapUsed: string;
+        heapTotal: string;
+    };
+    system: {
+        freeMB: string;
+        totalMB: string;
+        loadAverage: string;
+    };
+    status: {
+        uptime: string;
+        nodeVersion: string;
+    };
+}
+
+export default function DashboardVitals() {
+    const [vitals, setVitals] = useState<VitalsData | null>(null);
+
+    useEffect(() => {
+        const fetchVitals = async () => {
+            try {
+                const res = await fetch("/api/system/vitals");
+                const data = await res.json();
+                if (data.success) setVitals(data.vitals);
+            } catch (e) {
+                console.error("Vitals fetch failed:", e);
+            }
+        };
+
+        fetchVitals();
+        const interval = setInterval(fetchVitals, 10000); // 10s refresh
+        return () => clearInterval(interval);
+    }, []);
+
+    if (!vitals) return <div className="h-20 animate-pulse bg-zinc-900/50 rounded-xl border border-white/5" />;
+
+    return (
+        <div className="grid grid-cols-1 md:grid-cols-4 gap-4 mb-8">
+            <div className="bg-[#0d1117] border border-[#30363d] rounded-xl p-4 flex items-center gap-4 hover:border-blue-500/30 transition-all group">
+                <div className="p-3 rounded-lg bg-blue-500/10 text-blue-400 group-hover:scale-110 transition-transform">
+                    <Activity size={20} />
+                </div>
+                <div>
+                    <div className="text-[10px] text-zinc-500 uppercase font-bold tracking-widest">Process Load</div>
+                    <div className="text-lg font-mono text-zinc-200">{vitals.system.loadAverage}</div>
+                </div>
+            </div>
+
+            <div className="bg-[#0d1117] border border-[#30363d] rounded-xl p-4 flex items-center gap-4 hover:border-green-500/30 transition-all group">
+                <div className="p-3 rounded-lg bg-green-500/10 text-green-400 group-hover:scale-110 transition-transform">
+                    <Database size={20} />
+                </div>
+                <div>
+                    <div className="text-[10px] text-zinc-500 uppercase font-bold tracking-widest">Memory RSS</div>
+                    <div className="text-lg font-mono text-zinc-200">{vitals.process.rss} MB</div>
+                </div>
+            </div>
+
+            <div className="bg-[#0d1117] border border-[#30363d] rounded-xl p-4 flex items-center gap-4 hover:border-purple-500/30 transition-all group">
+                <div className="p-3 rounded-lg bg-purple-500/10 text-purple-400 group-hover:scale-110 transition-transform">
+                    <Server size={20} />
+                </div>
+                <div>
+                    <div className="text-[10px] text-zinc-500 uppercase font-bold tracking-widest">Uptime</div>
+                    <div className="text-lg font-mono text-zinc-200">{vitals.status.uptime}</div>
+                </div>
+            </div>
+
+             <div className="bg-[#0d1117] border border-[#30363d] rounded-xl p-4 flex items-center gap-4 hover:border-amber-500/30 transition-all group">
+                <div className="p-3 rounded-lg bg-amber-500/10 text-amber-400 group-hover:scale-110 transition-transform">
+                    <Cpu size={20} />
+                </div>
+                <div>
+                    <div className="text-[10px] text-zinc-500 uppercase font-bold tracking-widest">Free System</div>
+                    <div className="text-lg font-mono text-zinc-200">{vitals.system.freeMB} MB</div>
+                </div>
+            </div>
+        </div>
+    );
+}

components/dashboard/Dashboard.tsx

@@ -13,6 +13,7 @@ import {
 import { TEMPLATE_REGISTRY } from "@/constants/extensions";
 import Image from "next/image";
 import * as DropdownMenu from "@radix-ui/react-dropdown-menu";
+import DashboardVitals from "../DashboardVitals";
 
 interface Project {
     id: string;
@@ -67,6 +68,15 @@ export default function Dashboard() {
     }, []);
     useEffect(() => {
         fetchProjects();
+        
+        // PREDICTIVE HYDRATION: Pre-warm the largest or most recent project
+        if (projects.length > 0) {
+            const latest = projects[0];
+            fetch("/api/workspace", {
+                method: "POST",
+                body: JSON.stringify({ action: "prewarm", id: latest.id })
+            }).catch(console.error);
+        }
     }, [fetchProjects]);
 
 
@@ -216,6 +226,11 @@ export default function Dashboard() {
 
             {/* Body */}
             <div className="flex-1 overflow-hidden dashboard-grid">
+                {/* Dashboard Vitals (Strategic Integration) */}
+                <div className="col-span-full px-8 pt-6">
+                    <DashboardVitals />
+                </div>
+
                 {/* Left Panel */}
                 <div className="border-r border-(--border-subtle) flex flex-col overflow-y-auto p-6 gap-6">
                     {/* Greeting */}

lib/docker/manager.ts

@@ -4,6 +4,7 @@ import path from 'path';
 import Docker from 'dockerode';
 import { EventEmitter } from 'events';
 import { IdxEngine } from '../idx/idx-engine';
+import { HFStorage } from '../hf/storage';
 
 /**
  * Registry for native workspace processes (IDE instances running outside Docker)
@@ -113,6 +114,27 @@ export interface WorkspaceOperationResult {
     port?: string | number;
     appetizeUrl?: string;
     error?: string;
+    status?: 'hydrating' | 'ready';
+}
+
+/**
+ * PREDICTIVE HYDRATION: Pre-warms Nix profile and SDKs.
+ */
+export async function prewarmWorkspace(config: WorkspaceConfig): Promise<void> {
+    const workspaceRoot = process.env.WORKSPACE_ROOT || path.join(process.cwd(), 'workspaces');
+    const workspacePath = path.join(workspaceRoot, config.id);
+    
+    if (!fs.existsSync(workspacePath)) {
+        fs.mkdirSync(workspacePath, { recursive: true });
+    }
+
+    const idxConfig = IdxEngine.getIdxConfig(workspacePath);
+    if (idxConfig) {
+        // Run Nix sync and onCreate in background if not already warmed
+        IdxEngine.syncNixEnvironment(workspacePath, idxConfig, (msg) => {
+            provisioningBus.emit(`log:${config.id}`, `[HYDRATE] ${msg}`);
+        });
+    }
 }
 
 /**
@@ -126,6 +148,10 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
 
     log(`Provisioning hermetic environment for '${config.projectName}'...`);
     
+    // 0. HF PERSISTENCE: Restore profile from Dataset if available
+    await HFStorage.syncFromDataset((msg) => log(msg));
+    HFStorage.startAutoSave(300000); // Start 5m auto-save loop
+    
     // 1. Prepare Workspace Directory
     const workspaceRoot = process.env.WORKSPACE_ROOT || path.join(process.cwd(), 'workspaces');
     const workspacePath = path.join(workspaceRoot, config.id);
@@ -151,24 +177,24 @@ async function performProvisioning(config: WorkspaceConfig): Promise<WorkspaceOp
         log(`Baseline provisioned successfully.`);
     }
 
-    // 3. IDX Engine: Sync Environment
+    // 3. IDX Engine: Sync Environment (Async/Non-blocking)
     const idxConfig = IdxEngine.getIdxConfig(workspacePath);
     if (idxConfig) {
         log(`Declarative config detected. Initializing synchronization...`);
-        IdxEngine.syncNixEnvironment(workspacePath, idxConfig, (msg) => log(msg));
+        await IdxEngine.syncNixEnvironment(workspacePath, idxConfig, (msg) => log(msg));
         
         const flagPath = path.join(workspacePath, '.idx-created');
         if (!fs.existsSync(flagPath)) {
             if (idxConfig.onCreate) {
                 log(`Executing onCreate lifecycle hook...`);
-                IdxEngine.runHook(workspacePath, 'onCreate', idxConfig.onCreate, (msg) => log(msg));
+                await IdxEngine.runHook(workspacePath, 'onCreate', idxConfig.onCreate, (msg) => log(msg));
             }
             fs.writeFileSync(flagPath, new Date().toISOString());
         }
 
         if (idxConfig.onStart) {
             log(`Executing onStart lifecycle hook...`);
-            IdxEngine.runHook(workspacePath, 'onStart', idxConfig.onStart, (msg) => log(msg));
+            await IdxEngine.runHook(workspacePath, 'onStart', idxConfig.onStart, (msg) => log(msg));
         }
     }
 

lib/env-config.ts

@@ -0,0 +1,40 @@
+/**
+ * CodeVerse Environment Configuration & Requirements Manifest.
+ * Centralizing all system variables for production-grade reliability.
+ */
+export const ENV_CONFIG = {
+    // 1. Storage & Persistence
+    HF_TOKEN: process.env.HF_TOKEN,
+    HF_DATASET_ID: process.env.HF_DATASET_ID,
+    WORKSPACE_ROOT: process.env.WORKSPACE_ROOT || '/app/workspaces',
+
+    // 2. Build Acceleration
+    CACHIX_CACHE_NAME: process.env.CACHIX_CACHE_NAME,
+    CACHIX_AUTH_TOKEN: process.env.CACHIX_AUTH_TOKEN,
+
+    // 3. Infrastructure State
+    NODE_ENV: process.env.NODE_ENV || 'production',
+    SPACE_ID: process.env.SPACE_ID, // Hugging Face Space Identity
+    APP_BASE_URL: process.env.NEXTAUTH_URL || 'http://localhost:7860',
+
+    // 4. Database & Auth
+    AUTH_SECRET: process.env.AUTH_SECRET,
+    DATABASE_URL: process.env.TURSO_URL,
+    DATABASE_AUTH_TOKEN: process.env.TURSO_AUTH_TOKEN,
+};
+
+/**
+ * Validates that all critical infrastructure secrets are available.
+ */
+export function validateEnvironment() {
+    const missing = [];
+    if (!ENV_CONFIG.HF_TOKEN) missing.push('HF_TOKEN');
+    if (!ENV_CONFIG.HF_DATASET_ID) missing.push('HF_DATASET_ID');
+    if (!ENV_CONFIG.AUTH_SECRET) missing.push('AUTH_SECRET');
+    if (!ENV_CONFIG.DATABASE_URL) missing.push('TURSO_URL');
+
+    return {
+        valid: missing.length === 0,
+        missing: missing
+    };
+}

lib/hf/storage.ts

@@ -0,0 +1,73 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+
+/**
+ * Hugging Face Storage Utility for 2026 CodeVerse Persistence.
+ */
+export class HFStorage {
+    private static readonly HF_TOKEN = process.env.HF_TOKEN;
+    private static readonly HF_DATASET_ID = process.env.HF_DATASET_ID;
+    private static readonly PROFILE_PATH = path.join(process.env.HOME || '/home/node', '.nix-profile');
+    private static readonly WORKSPACE_ROOT = process.env.WORKSPACE_ROOT || '/app/workspaces';
+
+    /**
+     * Synchronizes the environment FROM the Hugging Face Dataset (Pull).
+     */
+    static async syncFromDataset(onLog?: (msg: string) => void): Promise<void> {
+        if (!this.HF_TOKEN || !this.HF_DATASET_ID) {
+            onLog?.(`[HF:STORAGE] Persistence layer inactive. HF_TOKEN or HF_DATASET_ID missing.`);
+            return;
+        }
+
+        onLog?.(`[HF:STORAGE] Pulling persistent profile from '${this.HF_DATASET_ID}'...`);
+        try {
+            // Using huggingface-cli to download the profile tarball
+            const tmpDir = '/tmp/hf-sync';
+            if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
+
+            execSync(`huggingface-cli download ${this.HF_DATASET_ID} profile.tar.gz --local-dir ${tmpDir} --token ${this.HF_TOKEN}`);
+            
+            if (fs.existsSync(path.join(tmpDir, 'profile.tar.gz'))) {
+                onLog?.(`[HF:STORAGE] Restoring Nix profile...`);
+                execSync(`tar -xzf ${path.join(tmpDir, 'profile.tar.gz')} -C ${process.env.HOME || '/home/node'}`);
+                onLog?.(`[HF:STORAGE] Profile restored successfully.`);
+            }
+        } catch (e) {
+            onLog?.(`[ERROR] Profile restoration failed. Starting with fresh environment.`);
+            console.error(e);
+        }
+    }
+
+    /**
+     * Synchronizes the environment TO the Hugging Face Dataset (Push).
+     */
+    static async syncToDataset(onLog?: (msg: string) => void): Promise<void> {
+        if (!this.HF_TOKEN || !this.HF_DATASET_ID) return;
+
+        onLog?.(`[HF:STORAGE] Saving persistent profile to '${this.HF_DATASET_ID}'...`);
+        try {
+            const tmpDir = '/tmp/hf-sync';
+            if (!fs.existsSync(tmpDir)) fs.mkdirSync(tmpDir, { recursive: true });
+
+            // Create a tarball of the .nix-profile
+            execSync(`tar -czf ${path.join(tmpDir, 'profile.tar.gz')} -C ${process.env.HOME || '/home/node'} .nix-profile`);
+
+            // Use huggingface-cli to upload
+            execSync(`huggingface-cli upload ${this.HF_DATASET_ID} ${tmpDir}/profile.tar.gz profile.tar.gz --token ${this.HF_TOKEN}`);
+            onLog?.(`[HF:STORAGE] Profile synchronized successfully.`);
+        } catch (e) {
+            onLog?.(`[ERROR] Profile synchronization failed.`);
+            console.error(e);
+        }
+    }
+
+    /**
+     * Starts the periodic persistence interval.
+     */
+    static startAutoSave(intervalMs: number = 300000) { // 5 minutes default
+        setInterval(async () => {
+            await this.syncToDataset((msg) => console.log(msg));
+        }, intervalMs);
+    }
+}

lib/idx/idx-engine.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 import path from 'path';
-import { execSync } from 'child_process';
+import { spawn } from 'child_process';
 
 /**
  * Interface representing the .idx/dev.nix configuration.
@@ -13,6 +13,7 @@ export interface IdxConfig {
 
 /**
  * IDX Engine for declarative workspace environments.
+ * Refactored for 2026 Asynchronous Execution to prevent Event Loop blocking.
  */
 export class IdxEngine {
   /**
@@ -25,7 +26,6 @@ export class IdxEngine {
     try {
       const content = fs.readFileSync(configPath, 'utf8');
       
-      // Simple regex-based parser for .idx/dev.nix (HCI: Nix syntax is complex, but we target common patterns)
       const packagesMatch = content.match(/packages\s*=\s*\[([\s\S]*?)\]/);
       const onCreateMatch = content.match(/onCreate\s*=\s*"{1,3}([\s\S]*?)"{1,3}/);
       const onStartMatch = content.match(/onStart\s*=\s*"{1,3}([\s\S]*?)"{1,3}/);
@@ -43,50 +43,75 @@ export class IdxEngine {
 
   /**
    * Synchronizes the Nix environment based on the declarative packages.
+   * ASYNCHRONOUS Spawning to prevent Blocking.
    */
-  static syncNixEnvironment(workspacePath: string, config: IdxConfig, onLog?: (msg: string) => void) {
+  static async syncNixEnvironment(workspacePath: string, config: IdxConfig, onLog?: (msg: string) => void): Promise<void> {
     if (!config.packages || config.packages.length === 0) return;
 
     const log = (msg: string) => { if (onLog) onLog(`[IDX:NIX] ${msg}`); };
     log(`Syncing system packages: ${config.packages.join(', ')}...`);
 
-    try {
-      // Use nix-env to install the declared packages into the home profile
-      // In a real Google Cloud Workstation, this would be a nix-shell or flake sync
-      for (const pkg of config.packages) {
-        log(`Installing ${pkg}...`);
-        // Note: pkg is usually 'pkgs.nodejs', we strip the prefix if needed
-        const pkgName = pkg.replace('pkgs.', '');
-        execSync(`nix-env -iA nixpkgs.${pkgName}`, { 
-          cwd: workspacePath, 
-          env: { ...process.env, HOME: workspacePath } 
+    // CACHIX ACCELERATION
+    const cachixName = process.env.CACHIX_CACHE_NAME;
+    if (cachixName) {
+      log(`Cachix acceleration detected for '${cachixName}'. Setting up cache...`);
+      try {
+        await new Promise<void>((resolve, reject) => {
+          const child = spawn('cachix', ['use', cachixName], {
+            cwd: workspacePath,
+            env: { ...process.env, HOME: workspacePath }
+          });
+          child.on('close', (code) => code === 0 ? resolve() : reject(new Error(`Cachix setup failed with code ${code}`)));
         });
+      } catch (e) {
+        log(`[WARN] Cachix setup failed. Falling back to default binary cache.`);
+        console.error(e);
       }
-      log(`Environment synchronized successfully.`);
-    } catch (e) {
-      log(`[ERROR] Nix sync failed. Reverting to base image SDKs.`);
-      console.error(e);
     }
+
+    for (const pkg of config.packages) {
+      log(`Installing ${pkg}...`);
+      const pkgName = pkg.replace('pkgs.', '');
+      
+      await new Promise<void>((resolve, reject) => {
+        const child = spawn('nix-env', ['-iA', `nixpkgs.${pkgName}`], {
+          cwd: workspacePath,
+          env: { ...process.env, HOME: workspacePath, NIX_PATH: `nixpkgs=https://github.com/NixOS/nixpkgs/archive/master.tar.gz` }
+        });
+
+        child.stdout.on('data', (data) => log(data.toString().trim()));
+        child.stderr.on('data', (data) => log(`[WARN] ${data.toString().trim()}`));
+        
+        child.on('close', (code) => {
+          if (code === 0) resolve();
+          else reject(new Error(`Nix installation of ${pkgName} failed with code ${code}`));
+        });
+      }).catch(err => log(`[ERROR] ${err.message}`));
+    }
+    log(`Environment synchronized successfully.`);
   }
 
   /**
    * Executes the 'onCreate' and 'onStart' hooks.
+   * ASYNCHRONOUS Spawning to prevent Blocking.
    */
-  static runHook(workspacePath: string, hookName: 'onCreate' | 'onStart', script: string, onLog?: (msg: string) => void) {
+  static async runHook(workspacePath: string, hookName: 'onCreate' | 'onStart', script: string, onLog?: (msg: string) => void): Promise<void> {
     const log = (msg: string) => { if (onLog) onLog(`[IDX:HOOK] ${hookName}: ${msg}`); };
     log(`Executing script...`);
 
-    try {
-      // Run the hook script in the workspace context
-      execSync(script, {
+    await new Promise<void>((resolve, reject) => {
+      const child = spawn('/bin/bash', ['-c', script], {
         cwd: workspacePath,
-        shell: '/bin/bash',
         env: { ...process.env, HOME: workspacePath }
       });
-      log(`Success.`);
-    } catch (e) {
-      log(`[ERROR] Hook failed with exit code 1.`);
-      console.error(e);
-    }
+
+      child.stdout.on('data', (data) => log(data.toString().trim()));
+      child.stderr.on('data', (data) => log(`[WARN] ${data.toString().trim()}`));
+      
+      child.on('close', (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Hook ${hookName} failed with code ${code}`));
+      });
+    }).catch(err => log(`[ERROR] ${err.message}`));
   }
 }

lib/mcp/bus.ts

@@ -0,0 +1,38 @@
+import { createTools } from "./tools";
+import type { ToolSet } from "ai";
+
+/**
+ * Model Context Protocol (MCP) Workspace Bus.
+ * Orchestrates multi-agent tool sharing across isolated CodeVerse environments.
+ */
+export class WorkspaceBus {
+    private static activeToolsets = new Map<string, ToolSet>();
+
+    /**
+     * Registers a workspace toolset on the shared collaboration bus.
+     */
+    static register(id: string, userId: string, workspaceName: string): ToolSet {
+        if (this.activeToolsets.has(id)) {
+            return this.activeToolsets.get(id)!;
+        }
+
+        const tools = createTools(userId, workspaceName);
+        this.activeToolsets.set(id, tools);
+        return tools;
+    }
+
+    /**
+     * Retrieves a toolset for a specific workspace context.
+     * Enables agents to "switch" between environments during complex multi-phase tasks.
+     */
+    static getToolset(id: string): ToolSet | undefined {
+        return this.activeToolsets.get(id);
+    }
+
+    /**
+     * Lists all currently active workspace identities on the bus.
+     */
+    static listActiveWorkspaces(): string[] {
+        return Array.from(this.activeToolsets.keys());
+    }
+}

next.config.ts

@@ -1,6 +1,7 @@
 import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
+  enablePrerenderSourceMaps: true,
   serverExternalPackages: ["dockerode", "ssh2"],
 };