pumuki-ast-hooks 5.3.1

package/scripts/hooks-system/bin/guard-supervisor.js

@@ -0,0 +1,516 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { getGitTreeState } = require('../application/services/GitTreeState');
+const GitTreeMonitorService = require('../application/services/monitoring/GitTreeMonitorService');
+const HeartbeatMonitorService = require('../application/services/monitoring/HeartbeatMonitorService');
+const { HealthCheckService } = require('../application/services/monitoring/HealthCheckService');
+const { createHealthCheckProviders } = require('../application/services/monitoring/HealthCheckProviders');
+const NotificationCenterService = require('../application/services/notification/NotificationCenterService');
+const { AutoRecoveryManager } = require('../application/services/recovery/AutoRecoveryManager');
+const { EvidenceContextManager } = require('../application/services/evidence/EvidenceContextManager');
+const { createUnifiedLogger } = require('../infrastructure/logging/UnifiedLoggerFactory');
+const PlatformDetectionService = require('../application/services/PlatformDetectionService');
+
+const repoRoot = process.cwd();
+const tmpDir = path.join(repoRoot, '.audit_tmp');
+const reportsDir = path.join(repoRoot, '.audit-reports');
+const lockDir = path.join(tmpDir, 'guard-supervisor.lock');
+const logPath = path.join(reportsDir, 'guard-supervisor.log');
+const restartDebounceMs = Number(process.env.HOOK_GUARD_AUTORELOAD_DEBOUNCE || 1500);
+const restartForceMs = Number(process.env.HOOK_GUARD_AUTORELOAD_FORCE || 3000);
+const dirtyTreeLimit = Number(process.env.HOOK_GUARD_DIRTY_TREE_LIMIT || 24);
+const dirtyTreeWarning = Number(process.env.HOOK_GUARD_DIRTY_TREE_WARNING || Math.max(1, Math.floor(dirtyTreeLimit / 2)));
+const dirtyTreeIntervalMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_INTERVAL || 60000);
+const dirtyTreeReminderMs = Number(process.env.HOOK_GUARD_DIRTY_TREE_REMINDER || 300000);
+const heartbeatRelativePath = process.env.HOOK_GUARD_HEARTBEAT_PATH || '.audit_tmp/guard-heartbeat.json';
+const heartbeatPath = path.isAbsolute(heartbeatRelativePath) ? heartbeatRelativePath : path.join(repoRoot, heartbeatRelativePath);
+const heartbeatIntervalMs = Number(process.env.HOOK_GUARD_HEARTBEAT_INTERVAL || 15000);
+const heartbeatMaxAgeMs = Number(process.env.HOOK_GUARD_HEARTBEAT_MAX_AGE || 60000);
+const heartbeatCheckIntervalMs = Number(process.env.HOOK_GUARD_HEARTBEAT_CHECK_INTERVAL || 5000);
+const debugLogPath = path.join(reportsDir, 'guard-debug.log');
+const healthIntervalMs = Number(process.env.HOOK_GUARD_HEALTH_INTERVAL || 60000);
+const evidenceIntervalMs = Number(process.env.HOOK_GUARD_EVIDENCE_INTERVAL || 120000);
+const evidencePlatforms = process.env.HOOK_GUARD_EVIDENCE_PLATFORMS
+  ? process.env.HOOK_GUARD_EVIDENCE_PLATFORMS.split(',').map(item => item.trim()).filter(Boolean)
+  : undefined;
+
+fs.mkdirSync(tmpDir, { recursive: true });
+fs.mkdirSync(reportsDir, { recursive: true });
+const unifiedLogger = createUnifiedLogger({
+  repoRoot,
+  component: 'GuardSupervisor',
+  fileName: 'guard-supervisor.log'
+});
+
+const notificationCenter = new NotificationCenterService({
+  repoRoot,
+  logger: unifiedLogger,
+  cooldownsByType: {
+    health_check_error: 300000,
+    health_check_warn: 120000,
+    auto_recovery_error: 300000,
+    auto_recovery_warn: 180000
+  }
+});
+
+const autoRecoveryManager = new AutoRecoveryManager({
+  repoRoot,
+  logger: unifiedLogger,
+  notificationCenter,
+  strategies: [
+    AutoRecoveryManager.createSupervisorRestartStrategy(),
+    {
+      id: 'guard-child-exit',
+      condition: ({ reason }) => typeof reason === 'string' && reason.startsWith('child-exit:guard'),
+      action: async ({ logger: recoveryLogger }) => {
+        recoveryLogger.info('Attempting guard restart via auto recovery');
+        return AutoRecoveryManager.runScript('start-guards.sh', ['restart']);
+      }
+    },
+    {
+      id: 'token-child-exit',
+      condition: ({ reason }) => typeof reason === 'string' && reason.startsWith('child-exit:tokenMonitor'),
+      action: async ({ logger: recoveryLogger }) => {
+        recoveryLogger.info('Attempting token monitor restart via auto recovery');
+        return AutoRecoveryManager.runScript('start-guards.sh', ['restart']);
+      }
+    }
+  ]
+});
+
+const originalEnqueue = notificationCenter.enqueue.bind(notificationCenter);
+notificationCenter.enqueue = payload => {
+  const result = originalEnqueue(payload);
+  if (payload && payload.type === 'health_check_error') {
+    autoRecoveryManager.recover({
+      key: 'health',
+      reason: `health-error:${payload.metadata?.reason || 'unknown'}`,
+      context: payload.metadata || {}
+    }).catch(error => {
+      unifiedLogger.error('GUARD_HEALTH_RECOVERY_ERROR', { message: error.message });
+    });
+  }
+  if (payload && payload.type === 'health_check_info') {
+    autoRecoveryManager.clear('health');
+  }
+  return result;
+};
+
+if (!acquireLock()) {
+  log('Another guard supervisor instance is already running. Exiting.');
+  process.exit(0);
+}
+
+const childDefs = {
+  guard: {
+    command: 'node',
+    args: [path.join(repoRoot, 'bin', 'watch-hooks.js')],
+    cwd: repoRoot,
+    stdio: 'inherit',
+    env: { ...process.env, HOOK_GUARD_DIRTY_TREE_DISABLED: 'true' }
+  },
+  tokenMonitor: {
+    command: 'bash',
+    args: [path.join(repoRoot, 'infrastructure', 'watchdog', 'token-monitor-loop.sh')],
+    cwd: repoRoot,
+    stdio: 'inherit',
+    env: process.env
+  }
+};
+
+const targets = [
+  'bin/watch-hooks.js',
+  'bin/guard-supervisor.js',
+  'bin/start-guards.sh',
+  'application/services/RealtimeGuardService.js',
+  'infrastructure/watchdog/token-monitor-loop.sh',
+  'infrastructure/watchdog/token-monitor.js',
+  'infrastructure/watchdog/token-tracker.sh'
+];
+
+const watchers = [];
+const children = new Map();
+let restartTimer = null;
+let restartPromise = Promise.resolve();
+let shuttingDown = false;
+
+const platformDetector = new PlatformDetectionService();
+
+function appendDebugLogSync(message) {
+  const timestamp = new Date().toISOString();
+  fs.appendFileSync(debugLogPath, `${timestamp}|${message}\n`);
+}
+
+const gitTreeMonitor = new GitTreeMonitorService({
+  repoRoot,
+  limit: dirtyTreeLimit,
+  warning: dirtyTreeWarning,
+  reminderMs: dirtyTreeReminderMs,
+  intervalMs: dirtyTreeIntervalMs,
+  getState: getGitTreeState,
+  notifier: (message, level) => log(message, { level }),
+  logger: unifiedLogger,
+  debugLogger: appendDebugLogSync
+});
+
+const heartbeatMonitor = new HeartbeatMonitorService({
+  heartbeatPath,
+  intervalMs: heartbeatIntervalMs,
+  statusProvider: buildHeartbeatPayload,
+  logger: unifiedLogger
+});
+
+const healthCheckProviders = createHealthCheckProviders({
+  repoRoot,
+  getGitTreeState,
+  heartbeatPath,
+  tokenUsagePath: path.join(tmpDir, 'token-usage.jsonl'),
+  evidencePath: path.join(repoRoot, '.AI_EVIDENCE.json'),
+  processes: [
+    {
+      name: 'watchHooks',
+      pidResolver: () => {
+        const description = describeChild('guard');
+        return description.running ? description.pid : null;
+      }
+    },
+    {
+      name: 'tokenMonitor',
+      pidResolver: () => {
+        const description = describeChild('tokenMonitor');
+        return description.running ? description.pid : null;
+      }
+    }
+  ]
+});
+
+const healthCheckService = new HealthCheckService({
+  repoRoot,
+  providers: healthCheckProviders,
+  notificationCenter,
+  logger: unifiedLogger,
+  outputFile: path.join(tmpDir, 'health-status.json'),
+  intervalMs: healthIntervalMs
+});
+
+const evidenceContextManager = new EvidenceContextManager({
+  repoRoot,
+  updateScript: path.join(repoRoot, 'bin', 'update-evidence.sh'),
+  notificationCenter,
+  logger: unifiedLogger,
+  intervalMs: evidenceIntervalMs,
+  autoPlatforms: evidencePlatforms
+});
+
+function acquireLock() {
+  try {
+    fs.mkdirSync(lockDir, { recursive: false });
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+
+function releaseLock() {
+  try {
+    fs.rmdirSync(lockDir);
+  } catch (error) {
+    log(`Error releasing lock: ${error.message}`);
+  }
+}
+
+function log(message, data = {}) {
+  const timestamp = formatLocalTimestamp();
+  fs.appendFileSync(logPath, `[${timestamp}] ${message}\n`);
+  unifiedLogger.info('GUARD_SUPERVISOR_EVENT', { message, ...data });
+}
+
+async function startChild(name) {
+  const def = childDefs[name];
+  if (!def) {
+    log(`Unknown child ${name}`);
+    return;
+  }
+  await stopChild(name);
+  const child = spawn(def.command, def.args, {
+    cwd: def.cwd,
+    stdio: def.stdio,
+    env: def.env || process.env
+  });
+  children.set(name, { child });
+  autoRecoveryManager.clear(name);
+  log(`${name} started (pid ${child.pid})`);
+  child.on('exit', (code, signal) => {
+    log(`${name} exited (code ${code ?? 'null'} signal ${signal ?? 'null'})`);
+    children.delete(name);
+    autoRecoveryManager.recover({
+      key: name,
+      reason: `child-exit:${name}`,
+      context: { code, signal }
+    }).catch(error => {
+      unifiedLogger.error('GUARD_CHILD_RECOVERY_ERROR', { name, message: error.message });
+    });
+    if (!shuttingDown) {
+      scheduleRestart(`${name}-exit:${code ?? 'null'}:${signal ?? 'null'}`);
+    }
+  });
+}
+
+function stopChild(name) {
+  const entry = children.get(name);
+  if (!entry) {
+    return Promise.resolve();
+  }
+  const { child } = entry;
+  return new Promise(resolve => {
+    const timeout = setTimeout(() => {
+      try {
+        child.kill('SIGKILL');
+      } catch (error) {
+        log(`Failed to SIGKILL ${name}: ${error.message}`);
+      }
+    }, restartForceMs);
+    child.once('exit', () => {
+      clearTimeout(timeout);
+      resolve();
+    });
+    try {
+      child.kill('SIGTERM');
+    } catch (error) {
+      log(`Failed to SIGTERM ${name}: ${error.message}`);
+      resolve();
+    }
+  });
+}
+
+function startAll() {
+  return Promise.all(Object.keys(childDefs).map(name => startChild(name)));
+}
+
+function stopAll() {
+  const names = Array.from(children.keys());
+  if (!names.length) {
+    return Promise.resolve();
+  }
+  return Promise.all(names.map(name => stopChild(name)));
+}
+
+function scheduleRestart(reason) {
+  if (restartTimer) {
+    return;
+  }
+  log(`Scheduling restart due to ${reason}`);
+  restartTimer = setTimeout(() => {
+    restartTimer = null;
+    restartAll(reason);
+  }, restartDebounceMs);
+}
+
+function restartAll(reason) {
+  restartPromise = restartPromise.then(async () => {
+    if (shuttingDown) {
+      return;
+    }
+    log(`Restarting guards (${reason})`);
+    await stopAll();
+    await startAll();
+    heartbeatMonitor.emitHeartbeat();
+    evidenceContextManager.ensureFresh('restart').catch(error => {
+      unifiedLogger.error('GUARD_EVIDENCE_REFRESH_FAILED', { message: error.message });
+    });
+    healthCheckService.collect('restart').catch(error => {
+      unifiedLogger.error('GUARD_HEALTHCHECK_RESTART_FAILED', { message: error.message });
+    });
+  });
+}
+
+function watchTargets() {
+  const directories = new Map();
+  targets.forEach(relPath => {
+    const absolute = path.join(repoRoot, relPath);
+    if (!fs.existsSync(absolute)) {
+      log(`Warning: ${relPath} missing; auto-restart will ignore it.`);
+      return;
+    }
+    const dir = path.dirname(absolute);
+    const list = directories.get(dir) || [];
+    list.push(path.basename(absolute));
+    directories.set(dir, list);
+  });
+
+  directories.forEach((files, dir) => {
+    try {
+      const watcher = fs.watch(dir, (event, filename) => {
+        if (!filename) {
+          return;
+        }
+        const normalized = filename.toString();
+        if (files.includes(normalized)) {
+          scheduleRestart(`${path.relative(repoRoot, path.join(dir, normalized))}:${event}`);
+        }
+      });
+      watchers.push(watcher);
+    } catch (error) {
+      log(`Error watching ${dir}: ${error.message}`);
+    }
+  });
+}
+
+function buildHeartbeatPayload() {
+  const guardStatus = describeChild('guard');
+  const tokenStatus = describeChild('tokenMonitor');
+  const status = guardStatus.running && tokenStatus.running ? 'healthy' : 'degraded';
+  const payload = {
+    timestamp: new Date().toISOString(),
+    supervisorPid: process.pid,
+    status,
+    guard: guardStatus,
+    tokenMonitor: tokenStatus
+  };
+  return payload;
+}
+
+function describeChild(name) {
+  const entry = children.get(name);
+  if (!entry || !entry.child) {
+    return { running: false, pid: null };
+  }
+  const { child } = entry;
+  if (!child || child.killed) {
+    return { running: false, pid: null };
+  }
+  return { running: true, pid: child.pid };
+}
+
+function formatLocalTimestamp(date = new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, '0');
+  const day = String(date.getDate()).padStart(2, '0');
+  const hours = String(date.getHours()).padStart(2, '0');
+  const minutes = String(date.getMinutes()).padStart(2, '0');
+  const seconds = String(date.getSeconds()).padStart(2, '0');
+  const milliseconds = String(date.getMilliseconds()).padStart(3, '0');
+  const offsetMinutes = date.getTimezoneOffset();
+  const sign = offsetMinutes <= 0 ? '+' : '-';
+  const absolute = Math.abs(offsetMinutes);
+  const offsetHours = String(Math.floor(absolute / 60)).padStart(2, '0');
+  const offsetMins = String(absolute % 60).padStart(2, '0');
+  return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}.${milliseconds}${sign}${offsetHours}:${offsetMins}`;
+}
+
+function shutdown() {
+  if (shuttingDown) {
+    return;
+  }
+  shuttingDown = true;
+  log('Shutting down guard supervisor');
+  watchers.forEach(w => {
+    try {
+      w.close();
+    } catch (error) {
+      log(`Error closing watcher: ${error.message}`);
+    }
+  });
+  gitTreeMonitor.stop();
+  heartbeatMonitor.stop();
+  stopHeartbeatStalenessMonitor();
+  healthCheckService.stop();
+  evidenceContextManager.stop();
+  autoRecoveryManager.clear('guard');
+  autoRecoveryManager.clear('tokenMonitor');
+  autoRecoveryManager.clear('health');
+  notificationCenter.shutdown();
+  stopAll().finally(() => {
+    releaseLock();
+    process.exit(0);
+  });
+}
+
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('exit', releaseLock);
+process.on('uncaughtException', error => {
+  log(`Uncaught exception: ${error.stack || error.message}`);
+  shutdown();
+});
+process.on('unhandledRejection', reason => {
+  log(`Unhandled rejection: ${reason instanceof Error ? reason.stack || reason.message : reason}`);
+  shutdown();
+});
+
+log('Guard supervisor started');
+
+let lastHeartbeatStale = false;
+let heartbeatStalenessTimer = null;
+
+function appendDebugLog(message) {
+  const timestamp = new Date().toISOString();
+  fs.appendFileSync(debugLogPath, `${timestamp}|${message}\n`);
+}
+
+function checkHeartbeatStaleness() {
+  if (shuttingDown) {
+    return;
+  }
+  try {
+    if (!fs.existsSync(heartbeatPath)) {
+      return;
+    }
+    const raw = fs.readFileSync(heartbeatPath, 'utf8');
+    if (!raw) {
+      return;
+    }
+    const data = JSON.parse(raw);
+    const timestamp = Date.parse(data.timestamp);
+    if (!Number.isFinite(timestamp)) {
+      return;
+    }
+    const age = Date.now() - timestamp;
+    if (age > heartbeatMaxAgeMs) {
+      if (!lastHeartbeatStale) {
+        lastHeartbeatStale = true;
+        appendDebugLog(`HEARTBEAT_ALERT|stale|ageMs=${age}`);
+      }
+    } else {
+      if (lastHeartbeatStale) {
+        lastHeartbeatStale = false;
+        appendDebugLog('HEARTBEAT_RECOVERED');
+      }
+    }
+  } catch (error) {
+    appendDebugLog(`HEARTBEAT_CHECK_ERROR|${error.message}`);
+  }
+}
+
+function startHeartbeatStalenessMonitor() {
+  if (heartbeatStalenessTimer) {
+    clearInterval(heartbeatStalenessTimer);
+  }
+  if (heartbeatCheckIntervalMs > 0 && heartbeatMaxAgeMs > 0) {
+    heartbeatStalenessTimer = setInterval(checkHeartbeatStaleness, heartbeatCheckIntervalMs);
+    if (heartbeatStalenessTimer && typeof heartbeatStalenessTimer.unref === 'function') {
+      heartbeatStalenessTimer.unref();
+    }
+  }
+}
+
+function stopHeartbeatStalenessMonitor() {
+  if (heartbeatStalenessTimer) {
+    clearInterval(heartbeatStalenessTimer);
+    heartbeatStalenessTimer = null;
+  }
+}
+
+startAll().then(() => {
+  watchTargets();
+  gitTreeMonitor.start();
+  heartbeatMonitor.start();
+  startHeartbeatStalenessMonitor();
+  healthCheckService.start('startup');
+  evidenceContextManager.start('startup');
+}).catch(error => {
+  log(`Failed to start guards: ${error.message}`);
+  shutdown();
+});

package/scripts/hooks-system/bin/hook-status.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+const EVIDENCE_PATH = path.join(process.cwd(), '.AI_EVIDENCE.json');
+const STATE_FILE = path.join(process.cwd(), '.audit_tmp', 'autonomous-state.json');
+const METRICS_FILE = path.join(process.cwd(), '.audit_tmp', 'hook-metrics.jsonl');
+
+function evidenceStatus() {
+  if (!fs.existsSync(EVIDENCE_PATH)) return 'missing';
+  try {
+    const data = JSON.parse(fs.readFileSync(EVIDENCE_PATH, 'utf8'));
+    const timestamp = new Date(data.timestamp).getTime();
+    const ageMinutes = (Date.now() - timestamp) / 60000;
+    return ageMinutes.toFixed(1) + ' min';
+  } catch (error) {
+    return 'invalid';
+  }
+}
+
+function stateStatus() {
+  if (!fs.existsSync(STATE_FILE)) return 'idle (default)';
+  try {
+    const data = JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+    return data.state || 'unknown';
+  } catch (error) {
+    return 'unknown';
+  }
+}
+
+function metricStatus() {
+  if (!fs.existsSync(METRICS_FILE)) return '0 entries';
+  const count = fs.readFileSync(METRICS_FILE, 'utf8').trim().split('\n').filter(Boolean).length;
+  return `${count} entries`;
+}
+
+console.log('Hook-System status');
+console.log(`- Evidence age: ${evidenceStatus()}`);
+console.log(`- Orchestrator state: ${stateStatus()}`);
+console.log(`- Metrics collected: ${metricStatus()}`);

package/scripts/hooks-system/bin/install-git-wrapper.sh

@@ -0,0 +1,53 @@
+#!/bin/bash
+# Install Git Wrapper to prevent --no-verify bypass
+
+set -e
+
+REPO_ROOT="$(git rev-parse --show-toplevel)"
+WRAPPER_SRC="$REPO_ROOT/scripts/hooks-system/infrastructure/guards/git-wrapper.sh"
+WRAPPER_DST="/usr/local/bin/git-protected"
+
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+RED='\033[0;31m'
+NC='\033[0m'
+
+echo "╔══════════════════════════════════════════════════════════╗"
+echo "║  🛡️  Git Wrapper Installation                            ║"
+echo "║  Prevents --no-verify bypass                            ║"
+echo "╚══════════════════════════════════════════════════════════╝"
+echo ""
+
+# Make wrapper executable
+chmod +x "$WRAPPER_SRC"
+
+# Copy to system path
+if sudo cp "$WRAPPER_SRC" "$WRAPPER_DST"; then
+  echo -e "${GREEN}✅ Git wrapper installed to $WRAPPER_DST${NC}"
+else
+  echo -e "${RED}❌ Failed to install wrapper (needs sudo)${NC}"
+  exit 1
+fi
+
+# Add alias to shell profiles
+for PROFILE in ~/.zshrc ~/.bashrc ~/.bash_profile; do
+  if [ -f "$PROFILE" ]; then
+    if ! grep -q "git-protected" "$PROFILE"; then
+      echo "" >> "$PROFILE"
+      echo "# Git wrapper - prevents --no-verify bypass" >> "$PROFILE"
+      echo "alias git='git-protected'" >> "$PROFILE"
+      echo -e "${GREEN}✅ Added alias to $PROFILE${NC}"
+    else
+      echo -e "${YELLOW}⚠️  Alias already exists in $PROFILE${NC}"
+    fi
+  fi
+done
+
+echo ""
+echo -e "${GREEN}╔══════════════════════════════════════════════════════════╗${NC}"
+echo -e "${GREEN}║  ✅ INSTALLATION COMPLETE                                ║${NC}"
+echo -e "${GREEN}║                                                          ║${NC}"
+echo -e "${GREEN}║  Restart your terminal or run: source ~/.zshrc          ║${NC}"
+echo -e "${GREEN}║                                                          ║${NC}"
+echo -e "${GREEN}║  --no-verify is now IMPOSSIBLE to use                   ║${NC}"
+echo -e "${GREEN}╚══════════════════════════════════════════════════════════╝${NC}"

package/scripts/hooks-system/bin/install.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+const InstallService = require('../application/services/installation/InstallService');
+
+// Run installation
+const installer = new InstallService();
+installer.run().catch(error => {
+  console.error('\n\x1b[31mInstallation failed:\x1b[0m', error);
+  process.exit(1);
+});

package/scripts/hooks-system/bin/kill-mcp-zombies.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# ═══════════════════════════════════════════════════════════════
+# Kill MCP Zombie Processes
+# ═══════════════════════════════════════════════════════════════
+# Kills any orphaned mcp-ai-evidence-watcher processes
+# Run before opening Cursor if you see zombie processes
+# ═══════════════════════════════════════════════════════════════
+
+set -euo pipefail
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+echo -e "${YELLOW}🧟 Searching for zombie MCP processes...${NC}"
+echo ""
+
+# Find all mcp-ai-evidence-watcher processes
+PIDS=$(pgrep -f "mcp-ai-evidence-watcher" || true)
+
+if [[ -z "$PIDS" ]]; then
+  echo -e "${GREEN}✅ No zombie processes found!${NC}"
+  exit 0
+fi
+
+# Count processes
+COUNT=$(echo "$PIDS" | wc -l | tr -d ' ')
+echo -e "${RED}❌ Found $COUNT zombie process(es):${NC}"
+echo ""
+
+# Show process details
+echo "$PIDS" | while read -r pid; do
+  ps -p "$pid" -o pid,command || true
+done
+
+echo ""
+echo -e "${YELLOW}🔪 Killing zombie processes...${NC}"
+
+# Kill processes
+echo "$PIDS" | while read -r pid; do
+  kill -9 "$pid" 2>/dev/null || true
+  echo -e "   ${GREEN}✓${NC} Killed PID $pid"
+done
+
+echo ""
+echo -e "${GREEN}✅ All zombie processes terminated!${NC}"
+echo -e "${YELLOW}ℹ️  Safe to restart Cursor now${NC}"