vibecodingmachine-cli 2025.12.25-25 → 2026.1.22-1441

package/src/commands/repo.js

@@ -43,34 +43,39 @@ async function getRepo() {
   }
 }
 
-async function initRepo() {
+async function initRepo(options = {}) {
   try {
     const cwd = process.cwd();
     const repoName = path.basename(cwd);
     const insideDir = path.join(cwd, '.vibecodingmachine');
     const siblingDir = path.join(path.dirname(cwd), `.vibecodingmachine-${repoName}`);
 
-    // Ask user where to create the directory
-    const { location } = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'location',
-        message: 'Where would you like to create the VibeCodingMachine directory?',
-        choices: [
-          {
-            name: `Inside this repository (${chalk.cyan('.vibecodingmachine')}) - suggested`,
-            value: 'inside',
-            short: 'Inside repository'
-          },
-          {
-            name: `As a sibling directory (${chalk.cyan(`../.vibecodingmachine-${repoName}`)}) - keeps configs separate from code`,
-            value: 'sibling',
-            short: 'Sibling directory'
-          }
-        ],
-        default: 'inside'
-      }
-    ]);
+    let location = options.location;
+
+    if (location !== 'inside' && location !== 'sibling') {
+      // Ask user where to create the directory
+      const answer = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'location',
+          message: 'Where would you like to create the VibeCodingMachine directory?',
+          choices: [
+            {
+              name: `Inside this repository (${chalk.cyan('.vibecodingmachine')}) - suggested`,
+              value: 'inside',
+              short: 'Inside repository'
+            },
+            {
+              name: `As a sibling directory (${chalk.cyan(`../.vibecodingmachine-${repoName}`)}) - keeps configs separate from code`,
+              value: 'sibling',
+              short: 'Sibling directory'
+            }
+          ],
+          default: 'inside'
+        }
+      ]);
+      location = answer.location;
+    }
 
     const allnightDir = location === 'inside' ? insideDir : siblingDir;
 

package/src/commands/requirements-remote.js

@@ -2,13 +2,18 @@ const chalk = require('chalk');
 const fs = require('fs-extra');
 const path = require('path');
 const inquirer = require('inquirer');
-const { t } = require('vibecodingmachine-core');
+const { t, errorReporter } = require('vibecodingmachine-core');
 
 /**
  * List requirements for a specific computer
  */
 async function listRemoteRequirements(computerId) {
   try {
+    // Validate input
+    if (!computerId || typeof computerId !== 'string') {
+      throw new TypeError('computerId must be a non-empty string');
+    }
+    
     const repoPath = process.cwd();
     const reqFilename = `REQUIREMENTS-${computerId}.md`;
     const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
@@ -54,6 +59,10 @@ async function listRemoteRequirements(computerId) {
     
   } catch (error) {
     console.error(chalk.red('\n✗ Failed to list requirements:'), error.message);
+    await errorReporter.reportError(error, {
+      command: 'listRemoteRequirements',
+      computerId
+    });
     throw error;
   }
 }
@@ -63,6 +72,15 @@ async function listRemoteRequirements(computerId) {
  */
 async function addRemoteRequirement(computerId, requirementText) {
   try {
+    // Validate inputs
+    if (!computerId || typeof computerId !== 'string') {
+      throw new TypeError('computerId must be a non-empty string');
+    }
+    
+    if (!requirementText || typeof requirementText !== 'string') {
+      throw new TypeError('requirementText must be a non-empty string');
+    }
+    
     const repoPath = process.cwd();
     const reqFilename = `REQUIREMENTS-${computerId}.md`;
     const reqPath = path.join(repoPath, '.vibecodingmachine', reqFilename);
@@ -144,6 +162,11 @@ DONE
     
   } catch (error) {
     console.error(chalk.red('\n✗ Failed to add requirement:'), error.message);
+    await errorReporter.reportError(error, {
+      command: 'addRemoteRequirement',
+      computerId,
+      requirementText
+    });
     throw error;
   }
 }
@@ -282,11 +305,20 @@ function parseRequirements(content) {
     
     // Parse requirements
     if (currentSection && line.startsWith('### ')) {
+      const title = line.replace(/^###\s*/, '').trim();
+
+      // Skip header-only lines like "Conflict Resolution:" which are used as group labels
+      if (/^Conflict Resolution:?$/i.test(title)) {
+        // Reset currentRequirement so we don't treat this header as an actual requirement
+        currentRequirement = null;
+        continue;
+      }
+
       if (currentRequirement) {
         sections[currentSection].push(currentRequirement);
       }
       currentRequirement = {
-        title: line.replace(/^###\s*/, '').trim(),
+        title,
         description: ''
       };
     } else if (currentRequirement && line.trim() && !line.startsWith('#')) {

package/src/commands/requirements.js

@@ -101,17 +101,113 @@ async function getReqPathOrExit() {
 
 async function list(options) {
   try {
-    const { reqPath } = await getReqPathOrExit();
-    if (!await fs.pathExists(reqPath)) {
+    const { repoPath, reqPath } = await getReqPathOrExit();
+    
+    // Handle --all-computers flag
+    if (options && options.allComputers) {
+      const vibeDir = path.join(repoPath, '.vibecodingmachine');
+      if (!await fs.pathExists(vibeDir)) {
+        console.log(chalk.yellow('No .vibecodingmachine directory found.'));
+        return;
+      }
+      
+      // Find all REQUIREMENTS-*.md files
+      const files = await fs.readdir(vibeDir);
+      const reqFiles = files.filter(f => f.startsWith('REQUIREMENTS') && f.endsWith('.md'));
+      
+      if (reqFiles.length === 0) {
+        console.log(chalk.yellow('No requirements files found.'));
+        return;
+      }
+      
+      // Extract computer info and requirements from each file
+      for (const file of reqFiles) {
+        const filePath = path.join(vibeDir, file);
+        const content = await fs.readFile(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        // Extract hostname from file
+        let hostname = 'Unknown';
+        const hostnameMatch = content.match(/- \*\*Hostname\*\*:\s*(.+)/);
+        if (hostnameMatch) {
+          hostname = hostnameMatch[1].trim();
+        }
+        
+        // Extract focus area
+        let focus = '';
+        const focusMatch = content.match(/## 🎯 Focus\n\*\*(.+)\*\*/);
+        if (focusMatch) {
+          focus = focusMatch[1].trim();
+        }
+        
+        // Filter by focus if specified
+        if (options.focus && focus && !focus.toLowerCase().includes(options.focus.toLowerCase())) {
+          continue;
+        }
+        
+        console.log(chalk.blue.bold(`\n📍 ${hostname}`) + (focus ? chalk.gray(` (${focus})`) : ''));
+        
+        // List requirements from this file
+        for (const line of lines) {
+          if (line.startsWith('### ') || line.startsWith('## ')) {
+            const statusFilter = options.status ? String(options.status).toLowerCase() : null;
+            if (!statusFilter || line.toLowerCase().includes(statusFilter)) {
+              console.log('  ' + line);
+            }
+          }
+        }
+      }
+      return;
+    }
+    
+    // Single computer mode (default or with --computer filter)
+    let targetReqPath = reqPath;
+    
+    // If computer filter specified, find that computer's requirements file
+    if (options && options.computer) {
+      const vibeDir = path.join(repoPath, '.vibecodingmachine');
+      const files = await fs.readdir(vibeDir);
+      const computerFile = files.find(f => 
+        f.startsWith('REQUIREMENTS') && 
+        f.endsWith('.md') && 
+        f.toLowerCase().includes(options.computer.toLowerCase())
+      );
+      
+      if (!computerFile) {
+        console.log(chalk.yellow(`No requirements file found for computer: ${options.computer}`));
+        return;
+      }
+      
+      targetReqPath = path.join(vibeDir, computerFile);
+    }
+    
+    if (!await fs.pathExists(targetReqPath)) {
       console.log(chalk.yellow('No REQUIREMENTS.md found.'));
       return;
     }
-    const content = await fs.readFile(reqPath, 'utf8');
+    
+    const content = await fs.readFile(targetReqPath, 'utf8');
     const lines = content.split('\n');
-    const filter = options && options.status ? String(options.status).toLowerCase() : null;
+    
+    // Extract focus area for focus filtering
+    let fileFocus = '';
+    const focusMatch = content.match(/## 🎯 Focus\n\*\*(.+)\*\*/);
+    if (focusMatch) {
+      fileFocus = focusMatch[1].trim();
+    }
+    
+    // Check focus filter
+    if (options && options.focus) {
+      if (!fileFocus || !fileFocus.toLowerCase().includes(options.focus.toLowerCase())) {
+        console.log(chalk.yellow(`No requirements match focus area: ${options.focus}`));
+        return;
+      }
+    }
+    
+    const statusFilter = options && options.status ? String(options.status).toLowerCase() : null;
     for (const line of lines) {
       if (line.startsWith('### ') || line.startsWith('## ')) {
-        if (!filter || line.toLowerCase().includes(filter)) {
+        if (!statusFilter || line.toLowerCase().includes(statusFilter)) {
           console.log(line);
         }
       }
@@ -124,10 +220,14 @@ async function list(options) {
 
 async function add(name, pkg, description) {
   try {
-    const { reqPath } = await getReqPathOrExit();
+    const { reqPath, repoPath } = await getReqPathOrExit();
     await fs.ensureFile(reqPath);
     let content = await fs.readFile(reqPath, 'utf8').catch(() => '');
 
+    // Get next requirement number
+    const { getNextRequirementNumber } = require('vibecodingmachine-core');
+    const reqNumber = await getNextRequirementNumber(repoPath);
+
     // Find the TODO section
     const todoSectionHeader = '## ⏳ Requirements not yet completed';
     if (!content.includes('Requirements not yet completed')) {
@@ -144,8 +244,8 @@ async function add(name, pkg, description) {
 
       // Insert right after the TODO section header
       if (!inserted && lines[i].startsWith('##') && lines[i].includes('Requirements not yet completed')) {
-        // Add requirement header
-        newLines.push(`### ${name}`);
+        // Add requirement header with number
+        newLines.push(`### R${reqNumber}: ${name}`);
 
         // Add package if provided (and not 'all')
         if (pkg && Array.isArray(pkg) && pkg.length > 0) {
@@ -363,6 +463,25 @@ async function working() {
   }
 }
 
+async function numberAll() {
+  try {
+    const { reqPath, repoPath } = await getReqPathOrExit();
+    if (!await fs.pathExists(reqPath)) {
+      console.log(chalk.yellow('No REQUIREMENTS.md found.'));
+      return;
+    }
+
+    console.log(chalk.cyan('Numbering all existing requirements...'));
+    const { numberAllRequirements } = require('vibecodingmachine-core');
+    const numbered = await numberAllRequirements(reqPath, repoPath);
+
+    console.log(chalk.green(`✓ Numbered ${numbered} requirements`));
+  } catch (error) {
+    console.error(chalk.red('Error numbering requirements:'), error.message);
+    process.exit(1);
+  }
+}
+
 module.exports = {
   list,
   add,
@@ -371,7 +490,8 @@ module.exports = {
   next,
   edit,
   watch,
-  rename
+  rename,
+  numberAll
 };
 
 

package/src/commands/setup.js

@@ -4,6 +4,7 @@ const os = require('os');
 const chalk = require('chalk');
 const inquirer = require('inquirer');
 const { t } = require('vibecodingmachine-core');
+const { promptWithDefaultsOnce } = require('../utils/prompt-helper');
 
 async function setupAlias() {
     console.log(chalk.bold.cyan(`\n🛠️  ${t('setup.alias.title')}\n`));
@@ -62,7 +63,7 @@ async function setupAlias() {
     }
 
     // Confirm with user
-    const { confirm } = await inquirer.prompt([
+    const { confirm } = await promptWithDefaultsOnce([
         {
             type: 'confirm',
             name: 'confirm',

package/src/commands/status.js

@@ -4,7 +4,7 @@ const os = require('os');
 const chalk = require('chalk');
 const { getRepoPath } = require('../utils/config');
 const { checkAutoModeStatus } = require('../utils/auto-mode');
-const { getRequirementsPath, t } = require('vibecodingmachine-core');
+const { getRequirementsPath, t, IDEHealthTracker } = require('vibecodingmachine-core');
 
 /**
  * Format IDE name for display
@@ -34,12 +34,50 @@ async function show() {
   const repoPath = await getRepoPath();
   console.log(chalk.bold(`\n${t('status.title')}`));
   console.log(chalk.gray(`${t('status.repository')}:`), chalk.cyan(formatPath(repoPath)));
+  
   const status = await checkAutoModeStatus();
   console.log(chalk.gray(`${t('status.auto.mode')}:`), status.running ? chalk.green(t('status.running')) : chalk.yellow(t('status.stopped')));
+  
   if (status.running) {
     console.log(chalk.gray(`${t('status.ide')}:`), chalk.cyan(formatIDEName(status.ide || 'cline')));
     console.log(chalk.gray(`${t('status.chats')}:`), chalk.cyan(status.chatCount || 0));
   }
+
+  // Display IDE health metrics
+  try {
+    const healthTracker = new IDEHealthTracker();
+    const allMetrics = await healthTracker.getAllHealthMetrics();
+    
+    if (allMetrics.size > 0) {
+      console.log(chalk.bold('\n📊 IDE Health Metrics:'));
+      
+      for (const [ideId, metrics] of allMetrics) {
+        const successRate = metrics.successRate > 0 ? `${(metrics.successRate * 100).toFixed(1)}%` : 'N/A';
+        const avgResponseTime = metrics.averageResponseTime > 0 ? `${Math.round(metrics.averageResponseTime / 1000)}s` : 'N/A';
+        
+        console.log(chalk.gray(`  ${formatIDEName(ideId)}:`));
+        console.log(chalk.gray(`    Success Rate:`), chalk.green(successRate));
+        console.log(chalk.gray(`    Avg Response:`), chalk.cyan(avgResponseTime));
+        console.log(chalk.gray(`    Interactions:`), chalk.blue(`${metrics.totalInteractions}`));
+        console.log(chalk.gray(`    Health:`), 
+          metrics.consecutiveFailures === 0 ? 
+            chalk.green('✅ Healthy') : 
+            chalk.yellow(`⚠️  ${metrics.consecutiveFailures} consecutive failures`)
+        );
+        console.log();
+      }
+
+      // Show recommended IDE
+      const recommendedIDE = await healthTracker.getRecommendedIDE();
+      if (recommendedIDE) {
+        console.log(chalk.bold('💡 Recommended IDE:'), chalk.cyan(formatIDEName(recommendedIDE)));
+      }
+    }
+  } catch (error) {
+    // Health tracking not available or error reading metrics
+    console.log(chalk.gray('\n📊 IDE Health:'), chalk.yellow('Not available'));
+  }
+  
   console.log();
 }
 

package/src/commands/sync.js

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 const Table = require('cli-table3');
 const SyncEngine = require('vibecodingmachine-core/src/sync/sync-engine');
-const { t } = require('vibecodingmachine-core');
+const { t, errorReporter } = require('vibecodingmachine-core');
 
 /**
  * Trigger immediate sync
@@ -44,6 +44,9 @@ async function syncNow() {
   } catch (error) {
     console.error(chalk.red(`\n✗ ${t('sync.failed')}`), error.message);
     console.log(chalk.gray(`\n${t('sync.tip.aws')}\n`));
+    await errorReporter.reportError(error, {
+      command: 'syncNow'
+    });
     // Don't throw - just log the error
   } finally {
     syncEngine.stop();
@@ -109,6 +112,9 @@ async function syncStatus() {
     
   } catch (error) {
     console.error(chalk.red(`\n✗ ${t('sync.status.failed')}`), error.message);
+    await errorReporter.reportError(error, {
+      command: 'syncStatus'
+    });
     throw error;
   } finally {
     syncEngine.stop();

package/src/utils/antigravity-js-handler.js

@@ -3,6 +3,7 @@ const {
   getProviderPreferences,
   saveProviderPreferences
 } = require('./provider-registry');
+const { AppleScriptManager } = require('vibecodingmachine-core');
 
 /**
  * Check if Antigravity agent has hit a rate limit.
@@ -34,12 +35,20 @@ function checkAntigravityRateLimit(stderr) {
  * @returns {Promise<{success: boolean, nextProvider: string|null, error: string|null}>}
  */
 async function handleAntigravityRateLimit() {
-  console.log(chalk.yellow('Antigravity rate limit detected. Disabling for this session.'));
+  console.log(chalk.yellow('Antigravity rate limit detected. Attempting to switch models within Antigravity first...'));
 
   try {
+    const appleScript = new AppleScriptManager();
+    const result = await appleScript.handleAntigravityQuotaLimit();
+
+    if (result.success) {
+      console.log(chalk.green(`Successfully switched to Antigravity model: ${result.model}`));
+      return { success: true, nextProvider: 'antigravity', modelSwitched: true, nextModel: result.model, error: null };
+    }
+
+    console.log(chalk.yellow(`Could not switch models within Antigravity: ${result.error || 'Unknown error'}. Switching to next provider...`));
+
     const prefs = await getProviderPreferences();
-    prefs.enabled.antigravity = false;
-    await saveProviderPreferences(prefs);
 
     const nextProvider = prefs.order.find(p => p !== 'antigravity' && prefs.enabled[p]);
 
@@ -50,7 +59,7 @@ async function handleAntigravityRateLimit() {
       return { success: false, nextProvider: null, error: 'No fallback providers available.' };
     }
   } catch (error) {
-    return { success: false, nextProvider: null, error: 'Failed to update provider preferences.' };
+    return { success: false, nextProvider: null, error: `Failed to handle rate limit: ${error.message}` };
   }
 }
 

package/src/utils/auth.js

@@ -8,7 +8,7 @@ const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage'
 // AWS Cognito configuration
 const COGNITO_DOMAIN = process.env.COGNITO_DOMAIN || 'vibecodingmachine-auth-1763598779.auth.us-east-1.amazoncognito.com';
 const CLIENT_ID = process.env.COGNITO_APP_CLIENT_ID || '3tbe1i2g36uqule92iuk6snuo3'; // Public client (no secret)
-const PREFERRED_PORT = 3000; // Preferred port, will auto-detect if unavailable
+const PREFERRED_PORT = 3001; // Use 3001 to avoid conflict with web dev server on 3000
 
 // Load shared access denied HTML
 function getAccessDeniedHTML() {
@@ -50,7 +50,7 @@ class CLIAuth {
 
         // Save new tokens
         await sharedAuth.saveToken(newTokens);
-        
+
         // Update user activity in database
         await this._updateUserActivity();
         return true;
@@ -70,6 +70,22 @@ class CLIAuth {
     return await sharedAuth.getToken();
   }
 
+  /**
+   * Get auth token string for API requests
+   * Ensures the token is valid and refreshed if necessary
+   */
+  async getAuthToken() {
+    // Check if authenticated and refresh if needed
+    const isAuth = await this.isAuthenticated();
+    if (!isAuth) return null;
+
+    const token = await sharedAuth.getToken();
+    if (!token) return null;
+
+    // Handle both string token and object with id_token
+    return typeof token === 'string' ? token : token.id_token;
+  }
+
   /**
    * Get user profile (uses shared storage)
    */
@@ -332,12 +348,10 @@ class CLIAuth {
 
     if (!portAvailable) {
       console.log(chalk.red(`\n❌ Port ${PORT} is already in use!\n`));
-      console.log(chalk.yellow('Port 3000 is required for authentication (OAuth callback).\n'));
-      console.log(chalk.white('To fix this, find and stop the process using port 3000:\n'));
+      console.log(chalk.yellow(`Port ${PORT} is required for authentication (OAuth callback).\n`));
+      console.log(chalk.white(`To fix this, find and stop the process using port ${PORT}:\n`));
       console.log(chalk.gray('  1. Find the process: ') + chalk.cyan(`lsof -i :${PORT}`));
-      console.log(chalk.gray('  2. Stop it: ') + chalk.cyan('kill <PID>'));
-      console.log(chalk.gray('\nOr if you\'re running the web dev server:'));
-      console.log(chalk.gray('  ') + chalk.cyan('cd packages/web && npm stop\n'));
+      console.log(chalk.gray('  2. Stop it: ') + chalk.cyan('kill <PID>\n'));
       throw new Error(`Port ${PORT} is already in use. Please free up this port and try again.`);
     }
 
@@ -595,7 +609,7 @@ class CLIAuth {
       `client_id=${CLIENT_ID}&` +
       `response_type=code&` +
       `scope=email+openid+profile&` +
-      `redirect_uri=http://localhost:3000/callback&` +
+      `redirect_uri=http://localhost:${PREFERRED_PORT}/callback&` +
       `code_challenge=${codeChallenge}&` +
       `code_challenge_method=S256&` +
       `identity_provider=Google&` +
@@ -610,7 +624,7 @@ class CLIAuth {
     console.log(chalk.yellow('3. Browser will redirect to localhost and show "connection refused" error'));
     console.log(chalk.yellow('   ' + chalk.gray('(This is expected - localhost is not accessible from your device)')));
     console.log(chalk.yellow('4. Copy the FULL URL from your browser address bar'));
-    console.log(chalk.yellow('   ' + chalk.gray('(It will start with: http://localhost:3000/callback?code=...)')));
+    console.log(chalk.yellow('   ' + chalk.gray(`(It will start with: http://localhost:${PREFERRED_PORT}/callback?code=...)`)));
     console.log(chalk.yellow('5. Paste it below\n'));
 
     const { callbackUrl } = await inquirer.prompt([{
@@ -624,8 +638,8 @@ class CLIAuth {
         if (!input.includes('code=')) {
           return 'Invalid URL - should contain "code=" parameter';
         }
-        if (!input.includes('localhost:3000/callback')) {
-          return 'Invalid callback URL - should be from localhost:3000/callback';
+        if (!input.includes(`localhost:${PREFERRED_PORT}/callback`)) {
+          return `Invalid callback URL - should be from localhost:${PREFERRED_PORT}/callback`;
         }
         return true;
       }
@@ -640,14 +654,12 @@ class CLIAuth {
         throw new Error('No authorization code found in URL');
       }
 
-      // Exchange code for tokens
-      console.log(chalk.gray('Exchanging authorization code for tokens...'));
       // Exchange code for tokens
       console.log(chalk.gray('Exchanging authorization code for tokens...'));
       const tokens = await this._exchangeCodeForTokens(
         code,
         codeVerifier,
-        'http://localhost:3000/callback'
+        `http://localhost:${PREFERRED_PORT}/callback`
       );
 
       const idToken = tokens.id_token;
@@ -711,10 +723,10 @@ class CLIAuth {
     try {
       // Decode JWT to get user info (without verification since we already validated)
       const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
       const userDb = new UserDatabase();
-      
+
       const userInfo = {
         email: payload.email,
         name: payload.name || payload.email.split('@')[0],
@@ -723,7 +735,7 @@ class CLIAuth {
 
       // Register/update user
       const user = await userDb.registerUser(userInfo);
-      
+
       // Register computer
       await userDb.registerComputer(user.userId, {
         interface: 'cli'
@@ -756,12 +768,12 @@ class CLIAuth {
 
       // Decode JWT to get user info
       const payload = JSON.parse(Buffer.from(token.id_token.split('.')[1], 'base64').toString());
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
       const userDb = new UserDatabase();
-      
+
       const userId = userDb.generateUserId(payload.email);
-      
+
       // Update last activity
       await userDb.updateUserActivity(userId, {
         lastActivity: Date.now()
@@ -786,12 +798,12 @@ class CLIAuth {
       if (!idToken) return;
 
       const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
       const userDb = new UserDatabase();
-      
+
       const userId = userDb.generateUserId(payload.email);
-      
+
       await userDb.trackActivity(userId, {
         interface: 'cli',
         action,
@@ -821,12 +833,31 @@ class CLIAuth {
       if (!idToken) return null;
 
       const payload = JSON.parse(Buffer.from(idToken.split('.')[1], 'base64').toString());
-      
+
       const UserDatabase = require('vibecodingmachine-core/src/database/user-schema');
       const userDb = new UserDatabase();
+
+      // Get user from API to get the correct userId format
+      const userDbClient = userDb.apiClient;
+      userDbClient.setAuthToken(idToken);
       
+      try {
+        const apiUser = await userDbClient.getUser();
+        if (apiUser && apiUser.userId) {
+          return {
+            userId: apiUser.userId, // Use API server's userId format
+            email: payload.email,
+            name: payload.name || payload.email.split('@')[0],
+            cognitoId: payload.sub
+          };
+        }
+      } catch (error) {
+        console.warn('Could not fetch user from API:', error.message);
+      }
+
+      // Fallback to generated userId if API call fails
       const userId = userDb.generateUserId(payload.email);
-      
+
       return {
         userId,
         email: payload.email,

package/src/utils/compliance-check.js

@@ -38,8 +38,18 @@ async function checkCompliance() {
       return true
     }
 
+    // Set auth token for database operations
+    const token = await auth.getAuthToken()
+    if (token) {
+      const UserDatabase = require('vibecodingmachine-core/src/database/user-schema')
+      const userDb = new UserDatabase()
+      userDb.setAuthToken(token)
+    }
+
     // Check and prompt for compliance
     const compliancePrompt = new CompliancePrompt()
+    // Set auth token for compliance manager
+    compliancePrompt.complianceManager.userDb.setAuthToken(token)
     const status = await compliancePrompt.complianceManager.checkComplianceStatus(user.userId)
     
     if (!status.needsAcknowledgment) {