@softerist/heuristic-mcp 3.0.17 → 3.2.0

package/features/lifecycle.js

@@ -54,13 +54,13 @@ async function readPidFromFile(filePath) {
         const pid = Number(parsed?.pid);
         if (Number.isInteger(pid)) return pid;
       } catch {
-        // fall through
+        
       }
     }
     const pid = parseInt(trimmed, 10);
     if (!Number.isNaN(pid)) return pid;
   } catch {
-    // ignore missing/invalid pid file
+    
   }
   return null;
 }
@@ -75,7 +75,7 @@ export async function stop() {
     const manualPid = process.env.HEURISTIC_MCP_PID;
 
     if (platform === 'win32') {
-      // 1. Try PID files first for reliability (per-workspace)
+      
       const pidFiles = await listPidFilePaths();
       for (const pidFile of pidFiles) {
         const pid = await readPidFromFile(pidFile);
@@ -85,7 +85,7 @@ export async function stop() {
           const pidValue = String(pid);
           if (!pids.includes(pidValue)) pids.push(pidValue);
         } catch (e) {
-          // If we lack permission, still attempt to stop by PID.
+          
           if (e.code === 'EPERM') {
             const pidValue = String(pid);
             if (!pids.includes(pidValue)) pids.push(pidValue);
@@ -95,35 +95,16 @@ export async function stop() {
         }
       }
 
-      // 2. Fallback to WMIC when CIM access is denied
-      if (pids.length === 0) {
-        try {
-          const { stdout } = await execPromise(
-            `wmic process where "CommandLine like '%heuristic-mcp%'" get ProcessId /FORMAT:LIST`
-          );
-          const matches = stdout.match(/ProcessId=(\d+)/g) || [];
-          for (const match of matches) {
-            const pid = match.replace('ProcessId=', '');
-            if (pid && !isNaN(pid) && parseInt(pid, 10) !== currentPid) {
-              if (!pids.includes(pid)) pids.push(pid);
-            }
-          }
-        } catch (_wmicErr) {
-          // ignore secondary failures
-        }
-      }
-
-      // 3. Fallback to process list with fuzzier matching (kill all heuristic-mcp instances)
       try {
         const { stdout } = await execPromise(
-          `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -and ($_.CommandLine -like '*heuristic-mcp*' -or $_.CommandLine -like '*heuristic-mcp\\\\index.js*' -or $_.CommandLine -like '*heuristic-mcp/index.js*') } | Select-Object -ExpandProperty ProcessId"`
+          `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^node(\\\\.exe)?$' -and $_.CommandLine -and ($_.CommandLine -like '*heuristic-mcp\\\\index.js*' -or $_.CommandLine -like '*heuristic-mcp/index.js*') } | Select-Object -ExpandProperty ProcessId"`
         );
         const listPids = stdout
           .trim()
           .split(/\s+/)
           .filter((p) => p && !isNaN(p) && parseInt(p) !== currentPid);
 
-        // Retrieve command lines to filter out workers
+        
         if (listPids.length > 0) {
           const { stdout: cmdOut } = await execPromise(
             `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -in @(${listPids.join(',')}) } | Select-Object ProcessId, CommandLine"`
@@ -150,15 +131,15 @@ export async function stop() {
           }
         }
       } catch (_e) {
-        /* ignore */
+        
       }
     } else {
-      // Unix: Use pgrep to get all matching PIDs
+      
       try {
         const { stdout } = await execPromise(`pgrep -fl "heuristic-mcp"`);
         const lines = stdout.trim().split(/\r?\n/);
 
-        // Filter out current PID, dead processes, and workers
+        
         pids = [];
         for (const line of lines) {
           const tokens = line.trim().split(/\s+/).filter(Boolean);
@@ -171,7 +152,7 @@ export async function stop() {
             const pid = parseInt(candidate, 10);
             if (!Number.isFinite(pid) || pid === currentPid) continue;
 
-            // Exclude workers when command line is present
+            
             if (
               !allNumeric &&
               (line.includes('embedding-worker') ||
@@ -188,18 +169,18 @@ export async function stop() {
                 pids.push(pidValue);
               }
             } catch (_e) {
-              /* ignore */
+              
             }
           }
         }
       } catch (e) {
-        // pgrep returns code 1 if no processes found, which is fine
+        
         if (e.code === 1) pids = [];
         else throw e;
       }
     }
 
-    // Manual PID override (best-effort)
+    
     if (manualPid) {
       const parts = String(manualPid)
         .split(/[,\s]+/)
@@ -221,7 +202,7 @@ export async function stop() {
       return;
     }
 
-    // Capture command lines before killing (best-effort)
+    
     try {
       if (platform === 'win32') {
         const { stdout } = await execPromise(
@@ -247,10 +228,10 @@ export async function stop() {
         }
       }
     } catch (_e) {
-      // ignore command line lookup failures
+      
     }
 
-    // Kill each process (Windows uses taskkill for compatibility)
+    
     let killedCount = 0;
     const killedPids = [];
     const failedPids = [];
@@ -262,7 +243,7 @@ export async function stop() {
           } catch (e) {
             const message = String(e?.message || '');
             if (message.includes('not found') || message.includes('not be found')) {
-              // Process already exited; treat as success.
+              
               killedCount++;
               killedPids.push(pid);
               continue;
@@ -285,7 +266,7 @@ export async function stop() {
         killedCount++;
         killedPids.push(pid);
       } catch (e) {
-        // Ignore if process already gone
+        
         if (e.code !== 'ESRCH') {
           failedPids.push(pid);
           console.warn(`[Lifecycle] Failed to kill PID ${pid}: ${e.message}`);
@@ -325,7 +306,7 @@ export async function stop() {
 
 export async function start(filter = null) {
   console.info('[Lifecycle] Ensuring server is configured...');
-  // Re-use the registration logic to ensure the config is present and correct
+  
   try {
     const { register } = await import('./register.js');
     await register(filter);
@@ -379,8 +360,13 @@ async function setMcpServerEnabled(enabled) {
         continue;
       }
 
-      const updatedEntry = { ...found.entry, disabled: !enabled };
-      const updatedText = upsertMcpServerEntryInText(raw, target, updatedEntry);
+      const updatedEntry = { ...found.entry };
+      if (enabled) {
+        delete updatedEntry.disabled;
+      } else {
+        updatedEntry.disabled = true;
+      }
+      const updatedText = upsertMcpServerEntryInText(raw, target, updatedEntry);
       if (!updatedText) {
         console.warn(`[Lifecycle] Failed to update ${name} config (unparseable layout).`);
         continue;
@@ -533,7 +519,7 @@ async function followFile(filePath, startPosition) {
       stream.pipe(process.stdout, { end: false });
       position = stats.size;
     } catch {
-      // ignore read errors while watching
+      
     }
   });
 
@@ -558,13 +544,165 @@ function formatDurationMs(ms) {
   return `${seconds}s`;
 }
 
-function formatDateTime(value) {
-  const date = value instanceof Date ? value : new Date(value);
-  if (Number.isNaN(date.getTime())) return null;
-  return `${date.toLocaleString()} (${date.toISOString()})`;
-}
-
-async function captureConsoleOutput(fn) {
+function formatDateTime(value) {
+  const date = value instanceof Date ? value : new Date(value);
+  if (Number.isNaN(date.getTime())) return null;
+  return `${date.toLocaleString()} (${date.toISOString()})`;
+}
+
+function parseFileProgressSummary(progressData) {
+  const message = String(progressData?.message || '');
+  if (!message) return null;
+
+  const indexedMatch = message.match(/Indexed\s+(\d+)\s*\/\s*(\d+)\s+files/i);
+  if (indexedMatch) {
+    return {
+      indexed: Number(indexedMatch[1]),
+      total: Number(indexedMatch[2]),
+    };
+  }
+
+  const completeMatch = message.match(/Complete:\s+\d+\s+chunks\s+from\s+(\d+)\s+files/i);
+  if (completeMatch) {
+    const total = Number(completeMatch[1]);
+    return { indexed: total, total };
+  }
+
+  const processingMatch = message.match(/Processing\s+(\d+)\s+changed files/i);
+  if (processingMatch) {
+    return { indexed: null, total: Number(processingMatch[1]) };
+  }
+
+  return null;
+}
+
+function normalizePathForCompare(targetPath) {
+  if (!targetPath) return '';
+  const resolved = path.resolve(targetPath);
+  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+}
+
+function extractWorkspaceFromCommandLine(commandLine) {
+  if (!commandLine || typeof commandLine !== 'string') return null;
+
+  const regex = /--workspace(?:=|\s+)("(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'|\S+)/g;
+  let match;
+  while ((match = regex.exec(commandLine)) !== null) {
+    let candidate = match[1] || '';
+    if (
+      (candidate.startsWith('"') && candidate.endsWith('"')) ||
+      (candidate.startsWith("'") && candidate.endsWith("'"))
+    ) {
+      candidate = candidate.slice(1, -1);
+    }
+    if (!candidate || candidate.includes('${')) continue;
+    return candidate;
+  }
+
+  return null;
+}
+
+async function collectRuntimeByPid({ pids, globalCacheRoot }) {
+  const pidSet = new Set((Array.isArray(pids) ? pids : []).map((pid) => Number(pid)));
+  const runtimeByPid = new Map();
+  if (pidSet.size === 0) return runtimeByPid;
+
+  const cacheDirs = await fs.readdir(globalCacheRoot).catch(() => []);
+  if (!Array.isArray(cacheDirs)) return runtimeByPid;
+
+  for (const dir of cacheDirs) {
+    const cacheDirectory = path.join(globalCacheRoot, dir);
+    const lockPath = path.join(cacheDirectory, 'server.lock.json');
+    const localPidPath = path.join(cacheDirectory, PID_FILE_NAME);
+    const logFile = path.join(cacheDirectory, 'logs', 'server.log');
+    const metaPath = path.join(cacheDirectory, 'meta.json');
+
+    let lockData = null;
+    try {
+      lockData = JSON.parse(await fs.readFile(lockPath, 'utf-8'));
+    } catch {
+      lockData = null;
+    }
+    const lockPid = Number(lockData?.pid);
+    if (Number.isInteger(lockPid) && pidSet.has(lockPid)) {
+      runtimeByPid.set(lockPid, {
+        pid: lockPid,
+        cacheDirectory,
+        workspace:
+          typeof lockData?.workspace === 'string' && lockData.workspace.trim()
+            ? lockData.workspace
+            : null,
+        workspaceSource: 'lock',
+        logFile,
+      });
+      continue;
+    }
+
+    const pidFromCache = await readPidFromFile(localPidPath);
+    if (!Number.isInteger(pidFromCache) || !pidSet.has(pidFromCache)) {
+      continue;
+    }
+    if (runtimeByPid.has(pidFromCache)) {
+      continue;
+    }
+
+    let metaWorkspace = null;
+    try {
+      const metaData = JSON.parse(await fs.readFile(metaPath, 'utf-8'));
+      if (typeof metaData?.workspace === 'string' && metaData.workspace.trim()) {
+        metaWorkspace = metaData.workspace;
+      }
+    } catch {
+      metaWorkspace = null;
+    }
+
+    runtimeByPid.set(pidFromCache, {
+      pid: pidFromCache,
+      cacheDirectory,
+      workspace: metaWorkspace,
+      workspaceSource: metaWorkspace ? 'meta' : 'cache',
+      logFile,
+    });
+  }
+
+  return runtimeByPid;
+}
+
+function selectRuntimeForStatus({ pids, runtimeByPid, requestedWorkspace }) {
+  if (!Array.isArray(pids) || pids.length === 0) return null;
+  if (!(runtimeByPid instanceof Map) || runtimeByPid.size === 0) return null;
+
+  if (requestedWorkspace) {
+    const requestedNormalized = normalizePathForCompare(requestedWorkspace);
+    for (const pid of pids) {
+      const runtime = runtimeByPid.get(pid);
+      if (!runtime?.workspace) continue;
+      if (normalizePathForCompare(runtime.workspace) === requestedNormalized) {
+        return runtime;
+      }
+    }
+  }
+
+  if (pids.length === 1) {
+    return runtimeByPid.get(pids[0]) || null;
+  }
+
+  for (const pid of pids) {
+    const runtime = runtimeByPid.get(pid);
+    if (runtime?.workspace) {
+      return runtime;
+    }
+  }
+
+  for (const pid of pids) {
+    const runtime = runtimeByPid.get(pid);
+    if (runtime) return runtime;
+  }
+
+  return null;
+}
+
+async function captureConsoleOutput(fn) {
   const original = {
     info: console.info,
     warn: console.warn,
@@ -629,46 +767,49 @@ function getGlobalCacheDir() {
   return process.env.XDG_CACHE_HOME || path.join(home, '.cache');
 }
 
-export async function status({ fix = false, cacheOnly = false, workspaceDir = null } = {}) {
-  try {
-    const pids = [];
+export async function status({ fix = false, cacheOnly = false, workspaceDir = null } = {}) {
+  try {
+    const pids = [];
     const now = new Date();
     const globalCacheRoot = path.join(getGlobalCacheDir(), 'heuristic-mcp');
     let logPath = 'unknown';
     let logStatus = '';
-    let cacheSummary = null;
-    let config = null;
-    let configLogs = [];
-
-    // 1. Check PID files first (per-workspace)
+    let cacheSummary = null;
+    let config = null;
+    let configLogs = [];
+    const cmdByPid = new Map();
+    let runtimeByPid = new Map();
+    let selectedRuntime = null;
+
+    
     const pidFiles = await listPidFilePaths();
     for (const pidFile of pidFiles) {
       const pid = await readPidFromFile(pidFile);
       if (!Number.isInteger(pid)) continue;
-      // Check if running
+      
       try {
         process.kill(pid, 0);
         pids.push(pid);
       } catch (_e) {
-        // Stale PID file
+        
         await fs.unlink(pidFile).catch(() => {});
       }
     }
 
-    // 2. Fallback to process list if no PID file found or process dead
+    
     if (pids.length === 0) {
       try {
         const myPid = process.pid;
         if (process.platform === 'win32') {
           const { stdout } = await execPromise(
-            `powershell -NoProfile -Command "Get-CimInstance Win32_Process -Filter \\"CommandLine LIKE '%heuristic-mcp%index.js%'\\" | Select-Object -ExpandProperty ProcessId"`
+            `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.Name -match '^node(\\\\.exe)?$' -and $_.CommandLine -and ($_.CommandLine -like '*heuristic-mcp\\\\index.js*' -or $_.CommandLine -like '*heuristic-mcp/index.js*') } | Select-Object -ExpandProperty ProcessId"`
           );
           const winPids = stdout
             .trim()
             .split(/\s+/)
             .filter((p) => p && !isNaN(p));
 
-          // Retrieve command lines to filter out workers
+          
           if (winPids.length > 0) {
             const { stdout: cmdOut } = await execPromise(
               `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -in @(${winPids.join(',')}) } | Select-Object ProcessId, CommandLine"`
@@ -701,7 +842,7 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
 
           for (const line of lines) {
             if (line.includes('heuristic-mcp/index.js') || line.includes('heuristic-mcp')) {
-              // Exclude workers
+              
               if (
                 line.includes('embedding-worker') ||
                 line.includes('embedding-process') ||
@@ -716,31 +857,30 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
               }
             }
           }
-          // Merge validPids into pids if not already present
+          
           for (const p of validPids) {
             if (!pids.includes(p)) pids.push(p);
           }
         }
       } catch (_e) {
-        /* ignore */
+        
       }
     }
 
     if (!cacheOnly) {
-      // STATUS OUTPUT
-      console.info(''); // spacer
+      
+      console.info(''); 
       if (pids.length > 0) {
         console.info(`[Lifecycle] 🟢 Server is RUNNING. PID(s): ${pids.join(', ')}`);
       } else {
         console.info('[Lifecycle] ⚪ Server is STOPPED.');
       }
-      if (pids.length > 1) {
-        console.info('[Lifecycle] ⚠️  Multiple servers detected; progress may be inconsistent.');
-      }
-      if (pids.length > 0) {
-        const cmdByPid = new Map();
-        try {
-          if (process.platform === 'win32') {
+      if (pids.length > 1) {
+        console.info('[Lifecycle] ⚠️  Multiple servers detected; progress may be inconsistent.');
+      }
+      if (pids.length > 0) {
+        try {
+          if (process.platform === 'win32') {
             const { stdout } = await execPromise(
               `powershell -NoProfile -Command "Get-CimInstance Win32_Process | Where-Object { $_.ProcessId -in @(${pids.join(',')}) } | Select-Object ProcessId, CommandLine"`
             );
@@ -764,38 +904,56 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
             }
           }
         } catch (_e) {
-          // ignore command line lookup failures
+          
         }
-      if (cmdByPid.size > 0) {
-        console.info('[Lifecycle] Active command lines:');
-        for (const pid of pids) {
+        if (cmdByPid.size > 0) {
+        console.info('[Lifecycle] Active command lines:');
+        for (const pid of pids) {
             const cmd = cmdByPid.get(pid);
             if (cmd) {
               console.info(`   ${pid}: ${cmd}`);
             }
-          }
-        }
-      }
-      console.info(''); // spacer
-    } // End if (!cacheOnly) - server status
-
-    if (!cacheOnly) {
-      try {
-        const captured = await captureConsoleOutput(() => loadConfig(workspaceDir));
-        config = captured.result;
-        configLogs = captured.lines;
-        logPath = getLogFilePath(config);
-        try {
-          await fs.access(logPath);
-          logStatus = '(exists)';
+          }
+        }
+
+        runtimeByPid = await collectRuntimeByPid({ pids, globalCacheRoot });
+        for (const [pid, runtime] of runtimeByPid.entries()) {
+          if (runtime?.workspace) continue;
+          const cmd = cmdByPid.get(pid);
+          const workspaceFromCmd = extractWorkspaceFromCommandLine(cmd);
+          if (workspaceFromCmd) {
+            runtime.workspace = workspaceFromCmd;
+            runtime.workspaceSource = 'cmd';
+          }
+        }
+        selectedRuntime = selectRuntimeForStatus({
+          pids,
+          runtimeByPid,
+          requestedWorkspace: workspaceDir,
+        });
+      }
+      console.info(''); 
+    } 
+
+    if (!cacheOnly) {
+      try {
+        const configWorkspaceDir = workspaceDir || selectedRuntime?.workspace || null;
+        const captured = await captureConsoleOutput(() => loadConfig(configWorkspaceDir));
+        config = captured.result;
+        configLogs = captured.lines;
+        logPath = selectedRuntime?.logFile || getLogFilePath(config);
+        try {
+          await fs.access(logPath);
+          logStatus = '(exists)';
         } catch {
           logStatus = '(not found)';
         }
-        if (config?.cacheDirectory) {
-          const metaFile = path.join(config.cacheDirectory, 'meta.json');
-          const progressFile = path.join(config.cacheDirectory, 'progress.json');
-          let metaData = null;
-          let progressData = null;
+        const statusCacheDirectory = selectedRuntime?.cacheDirectory || config?.cacheDirectory;
+        if (statusCacheDirectory) {
+          const metaFile = path.join(statusCacheDirectory, 'meta.json');
+          const progressFile = path.join(statusCacheDirectory, 'progress.json');
+          let metaData = null;
+          let progressData = null;
           try {
             metaData = JSON.parse(await fs.readFile(metaFile, 'utf-8'));
           } catch {
@@ -806,21 +964,27 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
           } catch {
             progressData = null;
           }
-          cacheSummary = {
-            cacheDir: config.cacheDirectory,
-            hasSnapshot: !!metaData,
-            snapshotTime: metaData?.lastSaveTime || null,
-            progress: progressData && typeof progressData.progress === 'number' ? progressData : null,
-          };
-        }
+          cacheSummary = {
+            cacheDir: statusCacheDirectory,
+            hasSnapshot: !!metaData,
+            snapshotTime: metaData?.lastSaveTime || null,
+            progress: progressData && typeof progressData.progress === 'number' ? progressData : null,
+          };
+        }
       } catch {
         logPath = 'unknown';
       }
 
-      if (config?.searchDirectory) {
-        console.info(`[Lifecycle] Workspace: ${config.searchDirectory}`);
-      }
-      console.info(`         Log file: ${logPath} ${logStatus}`.trimEnd());
+      const displayWorkspace = selectedRuntime?.workspace || config?.searchDirectory;
+      if (displayWorkspace) {
+        console.info(`[Lifecycle] Workspace: ${displayWorkspace}`);
+      }
+      if (selectedRuntime?.workspace && selectedRuntime.workspace !== config?.searchDirectory) {
+        console.info(
+          `         Workspace source: running server (${selectedRuntime.workspaceSource || 'runtime'})`
+        );
+      }
+      console.info(`         Log file: ${logPath} ${logStatus}`.trimEnd());
       if (cacheSummary?.cacheDir) {
         const snapshotLabel = cacheSummary.hasSnapshot ? 'available' : 'none';
         console.info(`[Cache] Snapshot: ${snapshotLabel}`);
@@ -838,18 +1002,18 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
           console.info('[Cache] Progress: idle');
         }
       }
-      console.info(''); // spacer
+      console.info(''); 
 
       if (configLogs.length > 0) {
         for (const line of configLogs) {
           console.info(line);
         }
-        console.info(''); // spacer
+        console.info(''); 
       }
     }
 
     if (cacheOnly) {
-      // APPEND LOGS INFO (Cache Status)
+      
       console.info('[Status] Inspecting cache status...\n');
 
       if (fix) {
@@ -867,15 +1031,28 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
           `[Status] Found ${cacheDirs.length} cache director${cacheDirs.length === 1 ? 'y' : 'ies'} in ${globalCacheRoot}`
         );
 
-        for (const dir of cacheDirs) {
-          const cacheDir = path.join(globalCacheRoot, dir);
-          const metaFile = path.join(cacheDir, 'meta.json');
-          const progressFile = path.join(cacheDir, 'progress.json');
-
-          console.info(`${'─'.repeat(60)}`);
-          console.info(`📁 Cache: ${dir}`);
-          console.info(`   Path: ${cacheDir}`);
-
+        for (const dir of cacheDirs) {
+          const cacheDir = path.join(globalCacheRoot, dir);
+          const metaFile = path.join(cacheDir, 'meta.json');
+          const progressFile = path.join(cacheDir, 'progress.json');
+          let progressData = null;
+          try {
+            progressData = JSON.parse(await fs.readFile(progressFile, 'utf-8'));
+          } catch {
+            
+          }
+          const hasNumericProgress = progressData && typeof progressData.progress === 'number';
+          const isProgressIncomplete =
+            !!hasNumericProgress &&
+            Number.isFinite(progressData.total) &&
+            progressData.total > 0 &&
+            progressData.progress < progressData.total;
+          const fileProgressSummary = parseFileProgressSummary(progressData);
+
+          console.info(`${'─'.repeat(60)}`);
+          console.info(`📁 Cache: ${dir}`);
+          console.info(`   Path: ${cacheDir}`);
+
           let metaData = null;
           try {
             metaData = JSON.parse(await fs.readFile(metaFile, 'utf-8'));
@@ -934,25 +1111,50 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
             if (Number.isFinite(metaData.lastWorkerThreads)) {
               console.info(`   Last worker threads: ${metaData.lastWorkerThreads}`);
             }
-            try {
-              const dirStats = await fs.stat(cacheDir);
-              console.info(`   Cache dir last write: ${formatDateTime(dirStats.mtime)}`);
-            } catch {
-              // ignore cache dir stat errors
-            }
-
-            // Verify indexing completion
-            if (metaData.filesIndexed && metaData.filesIndexed > 0) {
-              console.info(`   Cached index: ✅ COMPLETE (${metaData.filesIndexed} files)`);
-            } else if (metaData.filesIndexed === 0) {
-              console.info(`   Cached index: ⚠️  NO FILES (check excludePatterns)`);
-            } else {
-              console.info(`   Cached index: ⚠️  INCOMPLETE`);
-            }
-          } catch (err) {
-            if (err.code === 'ENOENT') {
-              try {
-                const stats = await fs.stat(cacheDir);
+            try {
+              const dirStats = await fs.stat(cacheDir);
+              console.info(`   Cache dir last write: ${formatDateTime(dirStats.mtime)}`);
+            } catch {
+              
+            }
+
+            const progressAfterSnapshot =
+              hasNumericProgress &&
+              progressData.updatedAt &&
+              metaData.lastSaveTime &&
+              new Date(progressData.updatedAt) > new Date(metaData.lastSaveTime);
+            const isIncrementalUpdateActive = Boolean(
+              hasNumericProgress && (isProgressIncomplete || progressAfterSnapshot)
+            );
+
+            
+            if (metaData.filesIndexed && metaData.filesIndexed > 0) {
+              if (isIncrementalUpdateActive) {
+                console.info(`   Cached snapshot: ✅ COMPLETE (${metaData.filesIndexed} files)`);
+              } else {
+                console.info(`   Cached index: ✅ COMPLETE (${metaData.filesIndexed} files)`);
+              }
+            } else if (metaData.filesIndexed === 0) {
+              console.info(`   Cached index: ⚠️  NO FILES (check excludePatterns)`);
+            } else {
+              console.info(`   Cached index: ⚠️  INCOMPLETE`);
+            }
+
+            if (
+              isIncrementalUpdateActive &&
+              Number.isFinite(fileProgressSummary?.total) &&
+              Number.isFinite(metaData.filesIndexed) &&
+              fileProgressSummary.total > metaData.filesIndexed
+            ) {
+              const delta = fileProgressSummary.total - metaData.filesIndexed;
+              console.info(
+                `   Current run target: ${fileProgressSummary.total} files (${delta} more than cached snapshot)`
+              );
+            }
+          } catch (err) {
+            if (err.code === 'ENOENT') {
+              try {
+                const stats = await fs.stat(cacheDir);
                 const ageMs = new Date() - stats.mtime;
                 if (ageMs < 10 * 60 * 1000) {
                   console.info(`   Status: ⏳ Initializing / Indexing in progress...`);
@@ -967,21 +1169,13 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
               }
             } else {
               console.info(`   Status: ❌ Invalid or corrupted (${err.message})`);
-            }
-          }
-
-          // Show latest indexing progress if available
-          let progressData = null;
-          try {
-            progressData = JSON.parse(await fs.readFile(progressFile, 'utf-8'));
-          } catch {
-            // no progress file
-          }
-
-          if (progressData && typeof progressData.progress === 'number') {
-            const updatedAt = progressData.updatedAt
-              ? formatDateTime(progressData.updatedAt)
-              : 'Unknown';
+            }
+          }
+
+          if (progressData && typeof progressData.progress === 'number') {
+            const updatedAt = progressData.updatedAt
+              ? formatDateTime(progressData.updatedAt)
+              : 'Unknown';
             const progressLabel = metaData
               ? 'Incremental update (post-snapshot)'
               : 'Initial index progress';
@@ -1026,18 +1220,18 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
               );
             }
           } else {
-            if (metaData) {
-              console.info('   Summary: Cached snapshot available; no update running.');
-            } else {
-              console.info('   Summary: No cached snapshot yet; indexing has not started.');
-            }
-          }
-
-          if (metaData && progressData && typeof progressData.progress === 'number') {
-            console.info('   Indexing state: Cached snapshot available; incremental update running.');
-          } else if (metaData) {
-            console.info('   Indexing state: Cached snapshot available; idle.');
-          } else if (progressData && typeof progressData.progress === 'number') {
+            if (metaData) {
+              console.info('   Summary: Cached snapshot available; no update running.');
+            } else {
+              console.info('   Summary: No cached snapshot yet; indexing has not started.');
+            }
+          }
+
+          if (metaData && isProgressIncomplete) {
+            console.info('   Indexing state: Cached snapshot available; incremental update running.');
+          } else if (metaData) {
+            console.info('   Indexing state: Cached snapshot available; idle.');
+          } else if (progressData && typeof progressData.progress === 'number') {
             console.info('   Indexing state: Initial index in progress; no cached snapshot yet.');
           } else {
             console.info('   Indexing state: No cached snapshot; idle.');
@@ -1064,22 +1258,22 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
       }
     }
 
-    // Show paths only for --status command
+    
     if (!cacheOnly) {
-      // SHOW PATHS
+      
       console.info('\n[Paths] Important locations:');
 
-    // Global npm bin
+    
     let npmBin = 'unknown';
     try {
       const { stdout } = await execPromise('npm config get prefix');
       npmBin = path.join(stdout.trim(), 'bin');
     } catch {
-      /* ignore */
+      
     }
     console.info(`   📦 Global npm bin: ${npmBin}`);
 
-    // Configs
+    
     const configLocations = [
       {
         name: 'Antigravity',
@@ -1115,12 +1309,12 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
       },
     ];
 
-    // Platform specific logic for config paths
+    
     if (process.platform === 'darwin') {
       configLocations[2].path = path.join(
         os.homedir(),
-        // Keep platform-native macOS path behavior.
-        // Home directory above is used only for Windows/Linux defaults.
+        
+        
         'Library',
         'Application Support',
         'Claude',
@@ -1173,7 +1367,7 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
         await fs.access(loc.path);
         status = '(exists)';
       } catch {
-        /* ignore */
+        
       }
       console.info(`      - ${loc.name}: ${loc.path} ${status}`);
     }
@@ -1182,7 +1376,7 @@ export async function status({ fix = false, cacheOnly = false, workspaceDir = nu
       console.info(`   💾 Cache root: ${globalCacheRoot}`);
       console.info(`   📁 Current dir: ${process.cwd()}`);
       console.info('');
-    } // End if (!cacheOnly) - paths
+    } 
   } catch (error) {
     console.error(`[Lifecycle] Failed to check status: ${error.message}`);
   }