vibecodingmachine-core 2025.11.2-9.855 → 2025.12.6-1702

package/src/utils/requirement-helpers.js

@@ -61,67 +61,87 @@ async function promoteToVerified(reqPath, requirementTitle) {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
-    const updatedLines = [];
     let inVerifySection = false;
-    let verifyCount = 0;
-    let requirementToMove = null;
+    let requirementStartIndex = -1;
+    let requirementEndIndex = -1;
+    const normalizedTitle = requirementTitle.trim();
 
-    for (const line of lines) {
-      if (line.includes('## ✅ Verified by AI screenshot')) {
+    // Find the requirement in TO VERIFY section (new ### format)
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmed = line.trim();
+
+      // Check if we're entering TO VERIFY section (multiple variants)
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###') && 
+          (trimmed.includes('TO VERIFY') || trimmed.includes('Verified by AI screenshot'))) {
         inVerifySection = true;
-        updatedLines.push(line);
         continue;
       }
 
-      if (inVerifySection && line.startsWith('## ')) {
+      // Check if we're leaving TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('##') && !trimmed.startsWith('###')) {
         inVerifySection = false;
-        updatedLines.push(line);
-        continue;
       }
 
-      if (inVerifySection && line.startsWith('- ')) {
-        const reqText = parseRequirementLine(line);
-        if (reqText === requirementTitle || reqText.includes(requirementTitle)) {
-          requirementToMove = reqText;
-          verifyCount++;
-          continue;
+      // Look for requirement in TO VERIFY section (### header format)
+      if (inVerifySection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        if (title === normalizedTitle || title.includes(normalizedTitle) || normalizedTitle.includes(title)) {
+          requirementStartIndex = i;
+          
+          // Find the end of this requirement block
+          for (let j = i + 1; j < lines.length; j++) {
+            const nextLine = lines[j].trim();
+            if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+              requirementEndIndex = j;
+              break;
+            }
+          }
+          if (requirementEndIndex === -1) {
+            requirementEndIndex = lines.length;
+          }
+          break;
         }
-        verifyCount++;
       }
+    }
 
-      updatedLines.push(line);
+    if (requirementStartIndex === -1) {
+      return false;
     }
 
-    if (requirementToMove) {
-      // CHANGELOG.md should be at repository root, not in .vibecodingmachine directory
-      const allnightDir = path.dirname(reqPath); // .vibecodingmachine directory
-      const repoRoot = path.dirname(allnightDir); // repository root (one level up)
-      const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
-      const timestamp = new Date().toISOString().split('T')[0];
-      const changelogEntry = `- ${requirementToMove} (${timestamp})`;
+    // Extract requirement block
+    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    const extractedTitle = lines[requirementStartIndex].replace(/^###\s*/, '').trim();
 
-      let changelogContent = '';
-      if (await fs.pathExists(changelogPath)) {
-        changelogContent = await fs.readFile(changelogPath, 'utf-8');
-      } else {
-        changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
-      }
+    // Remove requirement from TO VERIFY section
+    lines.splice(requirementStartIndex, requirementEndIndex - requirementStartIndex);
 
-      if (changelogContent.includes('## Verified Requirements')) {
-        changelogContent = changelogContent.replace(
-          '## Verified Requirements\n',
-          `## Verified Requirements\n${changelogEntry}\n`
-        );
-      } else {
-        changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
-      }
+    // Add to CHANGELOG.md
+    const allnightDir = path.dirname(reqPath);
+    const repoRoot = path.dirname(allnightDir);
+    const changelogPath = path.join(repoRoot, 'CHANGELOG.md');
+    const timestamp = new Date().toISOString().split('T')[0];
+    const changelogEntry = `- ${extractedTitle} (${timestamp})`;
+
+    let changelogContent = '';
+    if (await fs.pathExists(changelogPath)) {
+      changelogContent = await fs.readFile(changelogPath, 'utf-8');
+    } else {
+      changelogContent = '# Changelog\n\n## Verified Requirements\n\n';
+    }
 
-      await fs.writeFile(changelogPath, changelogContent);
-      await fs.writeFile(reqPath, updatedLines.join('\n'));
-      return true;
+    if (changelogContent.includes('## Verified Requirements')) {
+      changelogContent = changelogContent.replace(
+        '## Verified Requirements\n',
+        `## Verified Requirements\n${changelogEntry}\n`
+      );
+    } else {
+      changelogContent += `\n## Verified Requirements\n${changelogEntry}\n`;
     }
 
-    return false;
+    await fs.writeFile(changelogPath, changelogContent);
+    await fs.writeFile(reqPath, lines.join('\n'));
+    return true;
   } catch (error) {
     throw new Error(`Failed to promote requirement to verified: ${error.message}`);
   }
@@ -315,16 +335,17 @@ async function promoteTodoToVerify(reqPath, requirementTitle) {
  * Move requirement from TO VERIFY back to TODO section
  * @param {string} reqPath - Path to REQUIREMENTS file
  * @param {string} requirementTitle - Title of requirement to move
+ * @param {string} explanation - Optional explanation of what went wrong
  * @returns {Promise<boolean>} Success status
  */
-async function demoteVerifyToTodo(reqPath, requirementTitle) {
+async function demoteVerifyToTodo(reqPath, requirementTitle, explanation = '') {
   try {
     const content = await fs.readFile(reqPath, 'utf-8');
     const lines = content.split('\n');
     
-    // Find the requirement block in TO VERIFY section (### header format)
-    let requirementStartIndex = -1;
-    let requirementEndIndex = -1;
+    // Find ALL matching requirements in TO VERIFY section and remove them
+    // We'll collect all requirement blocks to remove, then process them
+    const requirementsToRemove = [];
     let inVerifySection = false;
     
     const verifySectionVariants = [
@@ -332,26 +353,56 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
       '## 🔍 TO VERIFY',
       '## TO VERIFY',
       '## ✅ TO VERIFY',
+      '## ✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
       '## ✅ Verified by AI screenshot'
     ];
     
+    // First pass: find all matching requirements in TO VERIFY section
     for (let i = 0; i < lines.length; i++) {
-      const line = lines[i].trim();
-      
-      if (verifySectionVariants.some(variant => line.includes(variant))) {
-        inVerifySection = true;
-        continue;
-      }
+      const line = lines[i];
+      const trimmed = line.trim();
       
-      if (inVerifySection && line.startsWith('##') && !line.startsWith('###')) {
-        break;
+      // Check if this is a TO VERIFY section header
+      if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+        const isToVerifyHeader = verifySectionVariants.some(variant => {
+          return trimmed === variant || trimmed.startsWith(variant) || 
+                 (trimmed.includes('Verified by AI screenshot') && trimmed.includes('Needs Human to Verify'));
+        });
+        
+        if (isToVerifyHeader) {
+          // Make sure it's not a VERIFIED section (without TO VERIFY)
+          if (!trimmed.includes('## 📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+            inVerifySection = true;
+            continue;
+          }
+        } else if (inVerifySection) {
+          // Check if we're leaving TO VERIFY section (hit a different section)
+          if (trimmed.includes('⏳ Requirements not yet completed') ||
+              trimmed.includes('## 📝 VERIFIED') ||
+              trimmed.includes('## ♻️ RECYCLED') ||
+              trimmed.includes('## 📦 RECYCLED') ||
+              trimmed.includes('## ❓ Requirements needing')) {
+            // We've left the TO VERIFY section
+            inVerifySection = false;
+          }
+        }
       }
       
-      if (inVerifySection && line.startsWith('###')) {
-        const title = line.replace(/^###\s*/, '').trim();
-        if (title && (title === requirementTitle || title.includes(requirementTitle) || requirementTitle.includes(title))) {
-          requirementStartIndex = i;
+      // Look for requirement in TO VERIFY section
+      if (inVerifySection && trimmed.startsWith('###')) {
+        const title = trimmed.replace(/^###\s*/, '').trim();
+        // Normalize titles for matching (handle TRY AGAIN prefixes)
+        const normalizedTitle = title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+        const normalizedRequirementTitle = requirementTitle.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+        
+        if (title && (title === requirementTitle || 
+                      normalizedTitle === normalizedRequirementTitle ||
+                      title.includes(requirementTitle) || 
+                      requirementTitle.includes(title) ||
+                      normalizedTitle.includes(normalizedRequirementTitle) ||
+                      normalizedRequirementTitle.includes(normalizedTitle))) {
           // Find the end of this requirement (next ### or ## header)
+          let requirementEndIndex = lines.length;
           for (let j = i + 1; j < lines.length; j++) {
             const nextLine = lines[j].trim();
             if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
@@ -359,31 +410,49 @@ async function demoteVerifyToTodo(reqPath, requirementTitle) {
               break;
             }
           }
-          if (requirementEndIndex === -1) {
-            requirementEndIndex = lines.length;
-          }
-          break;
+          
+          // Store this requirement to remove (we'll use the first one for moving to TODO)
+          requirementsToRemove.push({
+            start: i,
+            end: requirementEndIndex,
+            block: lines.slice(i, requirementEndIndex)
+          });
         }
       }
     }
     
-    if (requirementStartIndex === -1) {
+    if (requirementsToRemove.length === 0) {
       return false;
     }
     
-    // Extract the requirement block
-    const requirementBlock = lines.slice(requirementStartIndex, requirementEndIndex);
+    // Use the first matching requirement for moving to TODO (with TRY AGAIN prefix)
+    const firstRequirement = requirementsToRemove[0];
+    const requirementBlock = [...firstRequirement.block];
     
     // Update title with TRY AGAIN prefix
     const originalTitle = requirementBlock[0].replace(/^###\s*/, '').trim();
     const titleWithPrefix = addTryAgainPrefix(originalTitle);
     requirementBlock[0] = `### ${titleWithPrefix}`;
     
-    // Remove the requirement from its current location
-    const updatedLines = [
-      ...lines.slice(0, requirementStartIndex),
-      ...lines.slice(requirementEndIndex)
-    ];
+    // Add explanation to the requirement description if provided
+    if (explanation && explanation.trim()) {
+      // Find where to insert the explanation (after the title, before any existing content)
+      // Insert after first line (title) with a blank line and "What went wrong:" section
+      const explanationLines = [
+        '',
+        '**What went wrong (from previous attempt):**',
+        explanation.trim(),
+        ''
+      ];
+      requirementBlock.splice(1, 0, ...explanationLines);
+    }
+    
+    // Remove ALL matching requirements from TO VERIFY section (work backwards to preserve indices)
+    const updatedLines = [...lines];
+    for (let i = requirementsToRemove.length - 1; i >= 0; i--) {
+      const req = requirementsToRemove[i];
+      updatedLines.splice(req.start, req.end - req.start);
+    }
     
     // Find or create TODO section
     let todoIndex = -1;

package/src/utils/requirements-parser.js

@@ -0,0 +1,310 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Parse requirements file and extract all sections
+ * This matches the CLI's parsing logic to ensure consistency
+ * @param {string} content - The requirements file content
+ * @returns {Object} Parsed requirements with sections: requirements, completed, needInformation, changelog, verified
+ */
+function parseRequirementsFile(content) {
+  const lines = content.split('\n');
+  const requirements = [];
+  const completed = [];
+  const needInformation = [];
+  const changelog = [];
+  const verified = [];
+
+  let currentSection = '';
+  let inSection = false;
+
+  // Section detection patterns (matching CLI logic)
+  const sectionPatterns = {
+    todo: ['⏳ Requirements not yet completed', 'Requirements not yet completed'],
+    verify: [
+      '🔍 TO VERIFY BY HUMAN',
+      'TO VERIFY BY HUMAN',
+      '🔍 TO VERIFY',
+      'TO VERIFY',
+      '✅ TO VERIFY',
+      '✅ Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+      'Verified by AI screenshot. Needs Human to Verify and move to CHANGELOG',
+      'Verified by AI screenshot'
+    ],
+    verified: ['📝 VERIFIED', 'VERIFIED'],
+    changelog: ['CHANGELOG'],
+    needInformation: ['❓ Requirements needing', 'Requirements needing', 'needing manual feedback', 'needing information']
+  };
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+
+    // Check for section headers (## but not ###)
+    if (trimmed.startsWith('##') && !trimmed.startsWith('###')) {
+      // Determine which section we're entering
+      if (sectionPatterns.todo.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'todo';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verify.some(pattern => {
+        const matches = trimmed.includes(pattern);
+        // Make sure it's not a VERIFIED section (without TO VERIFY)
+        if (matches && !trimmed.includes('📝 VERIFIED') && !trimmed.match(/^##\s+VERIFIED$/i) && !trimmed.includes('📝 VERIFIED')) {
+          return true;
+        }
+        return false;
+      })) {
+        currentSection = 'verify';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.verified.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'verified';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.changelog.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'changelog';
+        inSection = true;
+        continue;
+      } else if (sectionPatterns.needInformation.some(pattern => trimmed.includes(pattern))) {
+        currentSection = 'needInformation';
+        inSection = true;
+        continue;
+      } else {
+        // Different section header - exit current section
+        if (inSection) {
+          // Check if we're leaving TO VERIFY section
+          if (currentSection === 'verify') {
+            const isTodoSection = trimmed.includes('⏳ Requirements not yet completed') || trimmed.includes('Requirements not yet completed');
+            const isVerifiedSection = trimmed === '## 📝 VERIFIED' || trimmed.startsWith('## 📝 VERIFIED');
+            const isRecycledSection = trimmed === '## ♻️ RECYCLED' || trimmed.startsWith('## ♻️ RECYCLED') ||
+              trimmed === '## 📦 RECYCLED' || trimmed.startsWith('## 📦 RECYCLED');
+            const isClarificationSection = trimmed.includes('## ❓ Requirements needing') || trimmed.includes('❓ Requirements needing');
+            
+            if (isVerifiedSection || isTodoSection || isRecycledSection || isClarificationSection) {
+              inSection = false;
+              currentSection = '';
+            }
+            // Otherwise continue - might be REJECTED or CHANGELOG which are not section boundaries for TO VERIFY
+          } else {
+            inSection = false;
+            currentSection = '';
+          }
+        }
+        continue;
+      }
+    }
+
+    // Parse requirements in new format (### header)
+    if (inSection && trimmed.startsWith('###')) {
+      const title = trimmed.replace(/^###\s*/, '').trim();
+
+      // Skip malformed requirements (title is just a package name, empty, or too short)
+      const packageNames = ['cli', 'core', 'electron-app', 'web', 'mobile', 'vscode-extension', 'sync-server'];
+      if (!title || title.length === 0 || packageNames.includes(title.toLowerCase())) {
+        continue;
+      }
+
+      const details = [];
+      let package = null;
+      let options = null;
+      let optionsType = null;
+
+      // Read package, description, and options
+      for (let j = i + 1; j < lines.length; j++) {
+        const nextLine = lines[j].trim();
+        
+        // Stop if we hit another requirement or section
+        if (nextLine.startsWith('###') || (nextLine.startsWith('##') && !nextLine.startsWith('###'))) {
+          break;
+        }
+        
+        // Check for PACKAGE line
+        if (nextLine.startsWith('PACKAGE:')) {
+          package = nextLine.replace(/^PACKAGE:\s*/, '').trim();
+        } 
+        // Check for OPTIONS line (for need information requirements)
+        else if (nextLine.startsWith('OPTIONS:')) {
+          optionsType = 'checkbox'; // default
+          const optionsText = nextLine.replace(/^OPTIONS:\s*/, '').trim();
+          // Parse options (could be checkbox or radio)
+          if (optionsText.includes('|')) {
+            options = optionsText.split('|').map(opt => opt.trim()).filter(opt => opt);
+          } else {
+            options = [optionsText];
+          }
+        }
+        // Description line (include all lines including empty ones to preserve formatting)
+        else if (nextLine !== undefined) {
+          details.push(nextLine);
+        }
+      }
+
+      const requirement = {
+        title,
+        description: details.join('\n'),
+        package,
+        options,
+        optionsType,
+        lineIndex: i
+      };
+
+      // Add to appropriate array based on current section
+      if (currentSection === 'todo') {
+        requirements.push(requirement);
+      } else if (currentSection === 'verify') {
+        completed.push(requirement);
+      } else if (currentSection === 'needInformation') {
+        needInformation.push(requirement);
+      } else if (currentSection === 'changelog') {
+        changelog.push(requirement);
+      } else if (currentSection === 'verified') {
+        verified.push(requirement);
+      }
+    }
+
+    // Also support old format (lines starting with -) for backwards compatibility
+    if (inSection && trimmed.startsWith('- ') && !trimmed.startsWith('###')) {
+      const requirementText = trimmed.substring(2).trim();
+      if (requirementText) {
+        // Extract date if present (format: "2025-12-25 2:35 PM MDT - " or "2025-10-03: ")
+        const dateTimeMatch = requirementText.match(/^(\d{4}-\d{2}-\d{2})(?:\s+\d{1,2}:\d{2}\s+[AP]M(?:\s+[A-Z]{2,5})?)?\s*[-:]\s*/);
+        const date = dateTimeMatch ? dateTimeMatch[1] : null;
+        const title = dateTimeMatch ? requirementText.substring(dateTimeMatch[0].length).trim() : requirementText;
+
+        const requirement = {
+          title: title.length > 100 ? title.substring(0, 100) + '...' : title,
+          description: title,
+          date: date
+        };
+
+        if (currentSection === 'todo') {
+          requirements.push(requirement);
+        } else if (currentSection === 'verify' || currentSection === 'completed') {
+          completed.push(requirement);
+        } else if (currentSection === 'changelog') {
+          changelog.push(requirement);
+        }
+      }
+    }
+  }
+
+  // Remove duplicates based on title (keep first occurrence)
+  const seenTitles = new Set();
+  const uniqueRequirements = [];
+  for (const req of requirements) {
+    const normalizedTitle = req.title.replace(/^TRY AGAIN \(\d+(st|nd|rd|th) time\):\s*/i, '').trim();
+    if (!seenTitles.has(normalizedTitle)) {
+      seenTitles.add(normalizedTitle);
+      uniqueRequirements.push(req);
+    }
+  }
+
+  return {
+    requirements: uniqueRequirements,
+    completed,
+    needInformation,
+    changelog,
+    verified
+  };
+}
+
+/**
+ * Load verified requirements from CHANGELOG.md
+ * @param {string} repoPath - Path to repository root
+ * @returns {Promise<Array>} Array of verified requirement titles
+ */
+async function loadVerifiedFromChangelog(repoPath) {
+  try {
+    const changelogPath = path.join(repoPath, 'CHANGELOG.md');
+    if (!await fs.pathExists(changelogPath)) {
+      return [];
+    }
+
+    const content = await fs.readFile(changelogPath, 'utf8');
+    const lines = content.split('\n');
+    const requirements = [];
+    let inVerifiedSection = false;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+
+      // Check for Verified Requirements section
+      if (trimmed.includes('## Verified Requirements')) {
+        inVerifiedSection = true;
+        continue;
+      }
+
+      // Exit section if we hit another ## header
+      if (inVerifiedSection && trimmed.startsWith('##') && !trimmed.includes('Verified Requirements')) {
+        break;
+      }
+
+      // Only collect items from within the Verified Requirements section
+      if (inVerifiedSection && trimmed.startsWith('- ') && trimmed.length > 10) {
+        const title = trimmed.substring(2).trim();
+        // Extract date if present (format: "Title (2025-12-05)")
+        const dateMatch = title.match(/^(.+?)\s*\((\d{4}-\d{2}-\d{2})\)$/);
+        const cleanTitle = dateMatch ? dateMatch[1].trim() : title;
+        const date = dateMatch ? dateMatch[2] : null;
+
+        requirements.push({
+          title: cleanTitle,
+          description: cleanTitle,
+          date: date
+        });
+      }
+    }
+
+    return requirements;
+  } catch (error) {
+    // If CHANGELOG.md doesn't exist or can't be read, return empty array
+    return [];
+  }
+}
+
+/**
+ * Load and parse requirements from file
+ * @param {string} reqPath - Path to requirements file
+ * @param {string} repoPath - Optional path to repository root (for loading CHANGELOG.md)
+ * @returns {Promise<Object>} Parsed requirements
+ */
+async function loadRequirementsFromFile(reqPath, repoPath = null) {
+  try {
+    const parsed = {
+      requirements: [],
+      completed: [],
+      needInformation: [],
+      changelog: [],
+      verified: []
+    };
+
+    if (await fs.pathExists(reqPath)) {
+      const content = await fs.readFile(reqPath, 'utf8');
+      const fileParsed = parseRequirementsFile(content);
+      Object.assign(parsed, fileParsed);
+    }
+
+    // Also load verified from CHANGELOG.md if repoPath is provided
+    if (repoPath) {
+      const verifiedFromChangelog = await loadVerifiedFromChangelog(repoPath);
+      // Merge with verified from requirements file (CHANGELOG.md takes precedence)
+      if (verifiedFromChangelog.length > 0) {
+        parsed.verified = verifiedFromChangelog;
+      }
+    }
+
+    return parsed;
+  } catch (error) {
+    throw new Error(`Failed to load requirements from file: ${error.message}`);
+  }
+}
+
+module.exports = {
+  parseRequirementsFile,
+  loadRequirementsFromFile,
+  loadVerifiedFromChangelog
+};
+
+
+

package/src/utils/update-checker.js

@@ -62,15 +62,26 @@ async function checkForUpdates(packageName, currentVersion) {
   });
 }
 
+/**
+ * Compare two timestamp-based versions (YYYY.MM.DD-HHMM)
+ * Returns true if version1 is newer than version2
+ */
+function isVersionNewer(version1, version2) {
+  // Versions are in format YYYY.MM.DD-HHMM, so string comparison works
+  // Normalize both versions (handle old format with dots too)
+  const normalize = (v) => v.replace(/\.(\d{2})(\d{2})$/, '-$1$2');
+  return normalize(version1) > normalize(version2);
+}
+
 /**
  * Check for CLI updates from S3 version manifest (unified with Electron)
  * Both CLI and Electron now use the same timestamp-based versioning from git commits
- * @param {string} currentVersion - Current CLI version (e.g., '2025.11.26.0519')
+ * @param {string} currentVersion - Current CLI version (e.g., '2025.11.26-0519')
  * @returns {Promise<Object>} Update info or null if no update available
  */
 async function checkForCLIUpdates(currentVersion) {
   return new Promise((resolve, reject) => {
-    const manifestUrl = `https://vibecodingmachine-website.s3.amazonaws.com/downloads/version.json?t=${Date.now()}`;
+    const manifestUrl = `https://d3fh7zgi8horze.cloudfront.net/downloads/version.json?t=${Date.now()}`;
 
     https.get(manifestUrl, (res) => {
       let data = '';
@@ -92,7 +103,8 @@ async function checkForCLIUpdates(currentVersion) {
           const latestVersion = manifest.version;
           const publishedDate = manifest.date;
 
-          if (latestVersion !== currentVersion) {
+          // Only show update if latest version is actually newer than current
+          if (latestVersion !== currentVersion && isVersionNewer(latestVersion, currentVersion)) {
             resolve({
               hasUpdate: true,
               currentVersion,

package/src/utils/version-checker.js

@@ -12,15 +12,16 @@ const CACHE_DURATION = 1000 * 60 * 60; // 1 hour
 const VERSION_URL = 'https://vibecodingmachine-website.s3.amazonaws.com/downloads/version.json';
 
 /**
- * Format version timestamp to YYYY.MM.DD.HHMM UTC
+ * Format version timestamp to YYYY.MM.DD-HHMM UTC
  */
 function formatVersionTimestamp(versionString) {
-  // Version format: YYYY.MM.DD.HHMM
-  const match = versionString.match(/^(\d{4})\.(\d{2})\.(\d{2})\.(\d{2})(\d{2})$/);
+  // Version format: YYYY.MM.DD-HHMM (or old format YYYY.MM.DD.HHMM for backward compat)
+  const match = versionString.match(/^(\d{4})\.(\d{2})\.(\d{2})[-.](\d{2})(\d{2})$/);
   if (!match) return versionString;
 
   const [, year, month, day, hour, minute] = match;
-  return `${year}.${month}.${day}.${hour}${minute} UTC`;
+  // Normalize to new format for display
+  return `${year}.${month}.${day}-${hour}${minute} UTC`;
 }
 
 /**
@@ -44,7 +45,7 @@ function formatLocalTime(isoTimestamp) {
       hour12: false
     }).format(date);
 
-    // Convert to YYYY.MM.DD.HHMM format
+    // Convert to YYYY.MM.DD-HHMM format
     const parts = formatted.match(/(\d{2})\/(\d{2})\/(\d{4}), (\d{2}):(\d{2})/);
     if (parts) {
       const [, month, day, year, hour, minute] = parts;