agileflow 2.84.1 → 2.85.0

package/scripts/agileflow-welcome.js

@@ -46,7 +46,70 @@ try {
   // Update checker not available
 }
 
-function getProjectInfo(rootDir) {
+/**
+ * PERFORMANCE OPTIMIZATION: Load all project files once into cache
+ * This eliminates duplicate file reads across multiple functions.
+ * Estimated savings: 40-80ms
+ */
+function loadProjectFiles(rootDir) {
+  const cache = {
+    status: null,
+    metadata: null,
+    settings: null,
+    sessionState: null,
+    configYaml: null,
+    cliPackage: null,
+  };
+
+  const paths = {
+    status: 'docs/09-agents/status.json',
+    metadata: 'docs/00-meta/agileflow-metadata.json',
+    settings: '.claude/settings.json',
+    sessionState: 'docs/09-agents/session-state.json',
+    configYaml: '.agileflow/config.yaml',
+    cliPackage: 'packages/cli/package.json',
+  };
+
+  for (const [key, relPath] of Object.entries(paths)) {
+    const fullPath = path.join(rootDir, relPath);
+    try {
+      if (!fs.existsSync(fullPath)) continue;
+      if (key === 'configYaml') {
+        cache[key] = fs.readFileSync(fullPath, 'utf8');
+      } else {
+        cache[key] = JSON.parse(fs.readFileSync(fullPath, 'utf8'));
+      }
+    } catch (e) {
+      // Silently ignore - file not available or invalid
+    }
+  }
+
+  return cache;
+}
+
+/**
+ * PERFORMANCE OPTIMIZATION: Batch git commands into single call
+ * Reduces subprocess overhead from 3 calls to 1.
+ * Estimated savings: 20-40ms
+ */
+function getGitInfo(rootDir) {
+  try {
+    const output = execSync(
+      'git branch --show-current && git rev-parse --short HEAD && git log -1 --format="%s"',
+      { cwd: rootDir, encoding: 'utf8', timeout: 5000 }
+    );
+    const lines = output.trim().split('\n');
+    return {
+      branch: lines[0] || 'unknown',
+      commit: lines[1] || 'unknown',
+      lastCommit: lines[2] || '',
+    };
+  } catch (e) {
+    return { branch: 'unknown', commit: 'unknown', lastCommit: '' };
+  }
+}
+
+function getProjectInfo(rootDir, cache = null) {
   const info = {
     name: 'agileflow',
     version: 'unknown',
@@ -66,61 +129,89 @@ function getProjectInfo(rootDir) {
   // 2. AgileFlow metadata (installed user projects - legacy)
   // 3. packages/cli/package.json (AgileFlow dev project)
   try {
-    // Primary: .agileflow/config.yaml
-    const configPath = path.join(rootDir, '.agileflow', 'config.yaml');
-    if (fs.existsSync(configPath)) {
-      const content = fs.readFileSync(configPath, 'utf8');
-      const versionMatch = content.match(/^version:\s*['"]?([0-9.]+)/m);
+    // Primary: .agileflow/config.yaml (use cache if available)
+    if (cache?.configYaml) {
+      const versionMatch = cache.configYaml.match(/^version:\s*['"]?([0-9.]+)/m);
       if (versionMatch) {
         info.version = versionMatch[1];
       }
+    } else if (cache?.metadata?.version) {
+      // Fallback: metadata from cache
+      info.version = cache.metadata.version;
+    } else if (cache?.cliPackage?.version) {
+      // Dev project: from cache
+      info.version = cache.cliPackage.version;
     } else {
-      // Fallback: metadata or dev project
-      const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
-      if (fs.existsSync(metadataPath)) {
-        const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
-        info.version = metadata.version || info.version;
+      // No cache - fall back to file reads (for backwards compatibility)
+      const configPath = path.join(rootDir, '.agileflow', 'config.yaml');
+      if (fs.existsSync(configPath)) {
+        const content = fs.readFileSync(configPath, 'utf8');
+        const versionMatch = content.match(/^version:\s*['"]?([0-9.]+)/m);
+        if (versionMatch) {
+          info.version = versionMatch[1];
+        }
       } else {
-        // Dev project: check packages/cli/package.json
-        const pkg = JSON.parse(
-          fs.readFileSync(path.join(rootDir, 'packages/cli/package.json'), 'utf8')
-        );
-        info.version = pkg.version || info.version;
+        const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+        if (fs.existsSync(metadataPath)) {
+          const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+          info.version = metadata.version || info.version;
+        } else {
+          const pkg = JSON.parse(
+            fs.readFileSync(path.join(rootDir, 'packages/cli/package.json'), 'utf8')
+          );
+          info.version = pkg.version || info.version;
+        }
       }
     }
   } catch (e) {
     // Silently fail - version will remain 'unknown'
   }
 
-  // Get git info
-  try {
-    info.branch = execSync('git branch --show-current', { cwd: rootDir, encoding: 'utf8' }).trim();
-    info.commit = execSync('git rev-parse --short HEAD', { cwd: rootDir, encoding: 'utf8' }).trim();
-    info.lastCommit = execSync('git log -1 --format="%s"', {
-      cwd: rootDir,
-      encoding: 'utf8',
-    }).trim();
-  } catch (e) {}
+  // Get git info (batched into single command for performance)
+  const gitInfo = getGitInfo(rootDir);
+  info.branch = gitInfo.branch;
+  info.commit = gitInfo.commit;
+  info.lastCommit = gitInfo.lastCommit;
 
-  // Get status info
+  // Get status info (use cache if available)
   try {
-    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
-    if (fs.existsSync(statusPath)) {
-      const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
-      if (status.stories) {
-        for (const [id, story] of Object.entries(status.stories)) {
-          info.totalStories++;
-          if (story.status === 'in_progress') {
-            info.wipCount++;
-            if (!info.currentStory) {
-              info.currentStory = { id, title: story.title };
+    const status = cache?.status;
+    if (status?.stories) {
+      for (const [id, story] of Object.entries(status.stories)) {
+        info.totalStories++;
+        if (story.status === 'in_progress') {
+          info.wipCount++;
+          if (!info.currentStory) {
+            info.currentStory = { id, title: story.title };
+          }
+        } else if (story.status === 'blocked') {
+          info.blockedCount++;
+        } else if (story.status === 'completed') {
+          info.completedCount++;
+        } else if (story.status === 'ready') {
+          info.readyCount++;
+        }
+      }
+    } else if (!cache) {
+      // No cache - fall back to file read
+      const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+      if (fs.existsSync(statusPath)) {
+        const statusData = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
+        if (statusData.stories) {
+          for (const [id, story] of Object.entries(statusData.stories)) {
+            info.totalStories++;
+            if (story.status === 'in_progress') {
+              info.wipCount++;
+              if (!info.currentStory) {
+                info.currentStory = { id, title: story.title };
+              }
+            } else if (story.status === 'blocked') {
+              info.blockedCount++;
+            } else if (story.status === 'completed') {
+              info.completedCount++;
+            } else if (story.status === 'ready') {
+              info.readyCount++;
             }
-          } else if (story.status === 'blocked') {
-            info.blockedCount++;
-          } else if (story.status === 'completed') {
-            info.completedCount++;
-          } else if (story.status === 'ready') {
-            info.readyCount++;
           }
         }
       }
@@ -130,25 +221,39 @@ function getProjectInfo(rootDir) {
   return info;
 }
 
-function runArchival(rootDir) {
+function runArchival(rootDir, cache = null) {
   const result = { ran: false, threshold: 7, archived: 0, remaining: 0 };
 
   try {
-    const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
-    if (fs.existsSync(metadataPath)) {
-      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    // Use cached metadata if available
+    const metadata = cache?.metadata;
+    if (metadata) {
       if (metadata.archival?.enabled === false) {
         result.disabled = true;
         return result;
       }
       result.threshold = metadata.archival?.threshold_days || 7;
+    } else {
+      // No cache - fall back to file read
+      const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+      if (fs.existsSync(metadataPath)) {
+        const metadataData = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+        if (metadataData.archival?.enabled === false) {
+          result.disabled = true;
+          return result;
+        }
+        result.threshold = metadataData.archival?.threshold_days || 7;
+      }
     }
 
-    const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
-    if (!fs.existsSync(statusPath)) return result;
+    // Use cached status if available
+    const status = cache?.status;
+    if (!status && !cache) {
+      const statusPath = path.join(rootDir, 'docs/09-agents/status.json');
+      if (!fs.existsSync(statusPath)) return result;
+    }
 
-    const status = JSON.parse(fs.readFileSync(statusPath, 'utf8'));
-    const stories = status.stories || {};
+    const stories = (status || {}).stories || {};
 
     const cutoffDate = new Date();
     cutoffDate.setDate(cutoffDate.getDate() - result.threshold);
@@ -182,15 +287,23 @@ function runArchival(rootDir) {
   return result;
 }
 
-function clearActiveCommands(rootDir) {
+function clearActiveCommands(rootDir, cache = null) {
   const result = { ran: false, cleared: 0, commandNames: [] };
 
   try {
     const sessionStatePath = path.join(rootDir, 'docs/09-agents/session-state.json');
-    if (!fs.existsSync(sessionStatePath)) return result;
 
-    const state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
-    result.ran = true;
+    // Use cached sessionState if available, but we still need to read fresh for clearing
+    // because we need to write back. Cache is only useful to check if file exists.
+    let state;
+    if (cache?.sessionState) {
+      state = cache.sessionState;
+      result.ran = true;
+    } else {
+      if (!fs.existsSync(sessionStatePath)) return result;
+      state = JSON.parse(fs.readFileSync(sessionStatePath, 'utf8'));
+      result.ran = true;
+    }
 
     // Handle new array format (active_commands)
     if (state.active_commands && state.active_commands.length > 0) {
@@ -245,52 +358,72 @@ function checkParallelSessions(rootDir) {
 
     result.available = true;
 
-    // Try to register current session and get status
+    // Try to use combined full-status command (saves ~200ms vs 3 separate calls)
     const scriptPath = fs.existsSync(managerPath) ? managerPath : SESSION_MANAGER_PATH;
 
-    // Register this session
     try {
-      const registerOutput = execSync(`node "${scriptPath}" register`, {
+      // PERFORMANCE: Single subprocess call instead of 3 (register + count + status)
+      const fullStatusOutput = execSync(`node "${scriptPath}" full-status`, {
         cwd: rootDir,
         encoding: 'utf8',
         stdio: ['pipe', 'pipe', 'pipe'],
       });
-      const registerData = JSON.parse(registerOutput);
-      result.registered = true;
-      result.currentId = registerData.id;
+      const data = JSON.parse(fullStatusOutput);
+
+      result.registered = data.registered;
+      result.currentId = data.id;
+      result.otherActive = data.otherActive || 0;
+      result.cleaned = data.cleaned || 0;
+
+      if (data.current) {
+        result.isMain = data.current.is_main === true;
+        result.nickname = data.current.nickname;
+        result.branch = data.current.branch;
+        result.sessionPath = data.current.path;
+      }
     } catch (e) {
-      // Registration failed, continue anyway
-    }
+      // Fall back to individual calls if full-status not available (older version)
+      try {
+        const registerOutput = execSync(`node "${scriptPath}" register`, {
+          cwd: rootDir,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const registerData = JSON.parse(registerOutput);
+        result.registered = true;
+        result.currentId = registerData.id;
+      } catch (e) {
+        // Registration failed
+      }
 
-    // Get count of other active sessions
-    try {
-      const countOutput = execSync(`node "${scriptPath}" count`, {
-        cwd: rootDir,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
-      const countData = JSON.parse(countOutput);
-      result.otherActive = countData.count || 0;
-    } catch (e) {
-      // Count failed
-    }
+      try {
+        const countOutput = execSync(`node "${scriptPath}" count`, {
+          cwd: rootDir,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const countData = JSON.parse(countOutput);
+        result.otherActive = countData.count || 0;
+      } catch (e) {
+        // Count failed
+      }
 
-    // Get detailed status for current session (for banner display)
-    try {
-      const statusOutput = execSync(`node "${scriptPath}" status`, {
-        cwd: rootDir,
-        encoding: 'utf8',
-        stdio: ['pipe', 'pipe', 'pipe'],
-      });
-      const statusData = JSON.parse(statusOutput);
-      if (statusData.current) {
-        result.isMain = statusData.current.is_main === true;
-        result.nickname = statusData.current.nickname;
-        result.branch = statusData.current.branch;
-        result.sessionPath = statusData.current.path;
+      try {
+        const statusOutput = execSync(`node "${scriptPath}" status`, {
+          cwd: rootDir,
+          encoding: 'utf8',
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const statusData = JSON.parse(statusOutput);
+        if (statusData.current) {
+          result.isMain = statusData.current.is_main === true;
+          result.nickname = statusData.current.nickname;
+          result.branch = statusData.current.branch;
+          result.sessionPath = statusData.current.path;
+        }
+      } catch (e) {
+        // Status failed
       }
-    } catch (e) {
-      // Status failed
     }
   } catch (e) {
     // Session system not available
@@ -299,29 +432,36 @@ function checkParallelSessions(rootDir) {
   return result;
 }
 
-function checkPreCompact(rootDir) {
+function checkPreCompact(rootDir, cache = null) {
   const result = { configured: false, scriptExists: false, version: null, outdated: false };
 
   try {
-    // Check if PreCompact hook is configured in settings
-    const settingsPath = path.join(rootDir, '.claude/settings.json');
-    if (fs.existsSync(settingsPath)) {
-      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    // Check if PreCompact hook is configured in settings (use cache if available)
+    const settings = cache?.settings;
+    if (settings) {
       if (settings.hooks?.PreCompact?.length > 0) {
         result.configured = true;
       }
+    } else {
+      // No cache - fall back to file read
+      const settingsPath = path.join(rootDir, '.claude/settings.json');
+      if (fs.existsSync(settingsPath)) {
+        const settingsData = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+        if (settingsData.hooks?.PreCompact?.length > 0) {
+          result.configured = true;
+        }
+      }
     }
 
-    // Check if the script exists
+    // Check if the script exists (must always check filesystem)
     const scriptPath = path.join(rootDir, 'scripts/precompact-context.sh');
     if (fs.existsSync(scriptPath)) {
       result.scriptExists = true;
     }
 
-    // Check configured version from metadata
-    const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
-    if (fs.existsSync(metadataPath)) {
-      const metadata = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+    // Check configured version from metadata (use cache if available)
+    const metadata = cache?.metadata;
+    if (metadata) {
       if (metadata.features?.precompact?.configured_version) {
         result.version = metadata.features.precompact.configured_version;
         // PreCompact v2.40.0+ has multi-command support
@@ -331,20 +471,40 @@ function checkPreCompact(rootDir) {
         result.outdated = true;
         result.version = 'unknown';
       }
+    } else if (!cache) {
+      // No cache - fall back to file read
+      const metadataPath = path.join(rootDir, 'docs/00-meta/agileflow-metadata.json');
+      if (fs.existsSync(metadataPath)) {
+        const metadataData = JSON.parse(fs.readFileSync(metadataPath, 'utf8'));
+        if (metadataData.features?.precompact?.configured_version) {
+          result.version = metadataData.features.precompact.configured_version;
+          result.outdated = compareVersions(result.version, '2.40.0') < 0;
+        } else if (result.configured) {
+          result.outdated = true;
+          result.version = 'unknown';
+        }
+      }
     }
   } catch (e) {}
 
   return result;
 }
 
-function checkDamageControl(rootDir) {
+function checkDamageControl(rootDir, cache = null) {
   const result = { configured: false, level: 'standard', patternCount: 0, scriptsOk: true };
 
   try {
-    // Check if PreToolUse hooks are configured in settings
-    const settingsPath = path.join(rootDir, '.claude/settings.json');
-    if (fs.existsSync(settingsPath)) {
-      const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+    // Check if PreToolUse hooks are configured in settings (use cache if available)
+    let settings = cache?.settings;
+    if (!settings && !cache) {
+      // No cache - fall back to file read
+      const settingsPath = path.join(rootDir, '.claude/settings.json');
+      if (fs.existsSync(settingsPath)) {
+        settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
+      }
+    }
+
+    if (settings) {
       if (settings.hooks?.PreToolUse && Array.isArray(settings.hooks.PreToolUse)) {
         // Check for damage-control hooks
         const hasDamageControlHooks = settings.hooks.PreToolUse.some(h =>
@@ -493,26 +653,112 @@ function getChangelogEntries(version) {
   return entries;
 }
 
-// Run auto-update if enabled
-async function runAutoUpdate(rootDir) {
-  try {
-    console.log(`${c.skyBlue}Updating AgileFlow...${c.reset}`);
-    // Use --force to skip prompts for non-interactive auto-update
-    execSync('npx agileflow@latest update --force', {
+// Run auto-update if enabled (quiet mode - minimal output)
+async function runAutoUpdate(rootDir, fromVersion, toVersion) {
+  const runUpdate = () => {
+    // Use stdio: 'pipe' to capture output instead of showing everything
+    return execSync('npx agileflow@latest update --force', {
       cwd: rootDir,
       encoding: 'utf8',
-      stdio: 'inherit',
+      stdio: 'pipe',
       timeout: 120000, // 2 minute timeout
     });
-    console.log(`${c.mintGreen}Update complete!${c.reset}`);
+  };
+
+  try {
+    console.log(`${c.skyBlue}Updating AgileFlow${c.reset} ${c.dim}v${fromVersion} → v${toVersion}${c.reset}`);
+    // Use --force to skip prompts for non-interactive auto-update
+    runUpdate();
+    console.log(`${c.mintGreen}✓ Update complete${c.reset}`);
     return true;
   } catch (e) {
-    console.log(`${c.peach}Auto-update failed: ${e.message}${c.reset}`);
-    console.log(`${c.dim}Run manually: npx agileflow update${c.reset}`);
+    // Check if this is a stale npm cache issue (ETARGET = version not found)
+    if (e.message && (e.message.includes('ETARGET') || e.message.includes('notarget'))) {
+      console.log(`${c.dim}  Clearing npm cache and retrying...${c.reset}`);
+      try {
+        execSync('npm cache clean --force', { stdio: 'pipe', timeout: 30000 });
+        runUpdate();
+        console.log(`${c.mintGreen}✓ Update complete${c.reset}`);
+        return true;
+      } catch (retryError) {
+        console.log(`${c.peach}Auto-update failed after cache clean${c.reset}`);
+        console.log(`${c.dim}  Run manually: npx agileflow update${c.reset}`);
+        return false;
+      }
+    }
+    console.log(`${c.peach}Auto-update failed${c.reset}`);
+    console.log(`${c.dim}  Run manually: npx agileflow update${c.reset}`);
     return false;
   }
 }
 
+/**
+ * PERFORMANCE OPTIMIZATION: Fast expertise count (directory scan only)
+ * Just counts expert directories without reading/validating each expertise.yaml.
+ * Saves ~50-150ms by avoiding 29 file reads.
+ * Full validation is available via /agileflow:validate-expertise command.
+ */
+function getExpertiseCountFast(rootDir) {
+  const result = { total: 0, passed: 0, warnings: 0, failed: 0, issues: [], validated: false };
+
+  // Find experts directory
+  let expertsDir = path.join(rootDir, '.agileflow', 'experts');
+  if (!fs.existsSync(expertsDir)) {
+    expertsDir = path.join(rootDir, 'packages', 'cli', 'src', 'core', 'experts');
+  }
+  if (!fs.existsSync(expertsDir)) {
+    return result;
+  }
+
+  try {
+    const domains = fs
+      .readdirSync(expertsDir, { withFileTypes: true })
+      .filter(d => d.isDirectory() && d.name !== 'templates');
+
+    result.total = domains.length;
+
+    // Quick check: just verify expertise.yaml exists in each directory
+    // Full validation (staleness, required fields) deferred to separate command
+    for (const domain of domains) {
+      const filePath = path.join(expertsDir, domain.name, 'expertise.yaml');
+      if (!fs.existsSync(filePath)) {
+        result.failed++;
+        result.issues.push(`${domain.name}: missing file`);
+      } else {
+        // Spot-check first few files for staleness (sample 3 max for speed)
+        if (result.passed < 3) {
+          try {
+            const content = fs.readFileSync(filePath, 'utf8');
+            const lastUpdatedMatch = content.match(/^last_updated:\s*['"]?(\d{4}-\d{2}-\d{2})/m);
+            if (lastUpdatedMatch) {
+              const lastDate = new Date(lastUpdatedMatch[1]);
+              const daysSince = Math.floor((Date.now() - lastDate.getTime()) / (1000 * 60 * 60 * 24));
+              if (daysSince > 30) {
+                result.warnings++;
+                result.issues.push(`${domain.name}: stale (${daysSince}d)`);
+              } else {
+                result.passed++;
+              }
+            } else {
+              result.passed++;
+            }
+          } catch (e) {
+            result.passed++;
+          }
+        } else {
+          // Assume rest are ok for fast display
+          result.passed++;
+        }
+      }
+    }
+  } catch (e) {
+    // Silently fail
+  }
+
+  return result;
+}
+
+// Full validation function (kept for /agileflow:validate-expertise command)
 function validateExpertise(rootDir) {
   const result = { total: 0, passed: 0, warnings: 0, failed: 0, issues: [] };
 
@@ -950,13 +1196,21 @@ function formatSessionBanner(parallelSessions) {
 // Main
 async function main() {
   const rootDir = getProjectRoot();
-  const info = getProjectInfo(rootDir);
-  const archival = runArchival(rootDir);
-  const session = clearActiveCommands(rootDir);
-  const precompact = checkPreCompact(rootDir);
+
+  // PERFORMANCE: Load all project files once into cache
+  // This eliminates 6-8 duplicate file reads across functions
+  const cache = loadProjectFiles(rootDir);
+
+  // All functions now use cached file data where possible
+  const info = getProjectInfo(rootDir, cache);
+  const archival = runArchival(rootDir, cache);
+  const session = clearActiveCommands(rootDir, cache);
+  const precompact = checkPreCompact(rootDir, cache);
   const parallelSessions = checkParallelSessions(rootDir);
-  const expertise = validateExpertise(rootDir);
-  const damageControl = checkDamageControl(rootDir);
+  // PERFORMANCE: Use fast expertise count (directory scan only, ~3 file samples)
+  // Full validation available via /agileflow:validate-expertise
+  const expertise = getExpertiseCountFast(rootDir);
+  const damageControl = checkDamageControl(rootDir, cache);
 
   // Check for updates (async, cached)
   let updateInfo = {};
@@ -964,11 +1218,18 @@ async function main() {
     updateInfo = await checkUpdates();
 
     // If auto-update is enabled and update available, run it
-    if (updateInfo.available && updateInfo.autoUpdate) {
-      const updated = await runAutoUpdate(rootDir);
+    if (updateInfo.available && updateInfo.autoUpdate && updateInfo.latest) {
+      const updated = await runAutoUpdate(rootDir, info.version, updateInfo.latest);
       if (updated) {
-        // Re-run welcome after update (the new version will show changelog)
-        return;
+        // Mark as "just updated" so the welcome table shows it
+        updateInfo.justUpdated = true;
+        updateInfo.previousVersion = info.version;
+        // Update local info with new version
+        info.version = updateInfo.latest;
+        // Get changelog entries for the new version
+        updateInfo.changelog = getChangelogEntries(updateInfo.latest);
+        // Clear the "update available" flag since we just updated
+        updateInfo.available = false;
       }
     }