fix(windows): prevent zombie process accumulation on app close

apps/frontend/src/__tests__/integration/subprocess-spawn.test.ts

@@ -26,6 +26,9 @@ const mockProcess = Object.assign(new EventEmitter(), {
   killed: false,
   kill: vi.fn(() => {
     mockProcess.killed = true;
+    // Emit exit event synchronously to simulate process termination
+    // (needed for killAllProcesses wait - using nextTick for more predictable timing)
+    process.nextTick(() => mockProcess.emit('exit', 0, null));
     return true;
   })
 });
@@ -290,7 +293,12 @@ describe('Subprocess Spawn Integration', () => {
       const result = manager.killTask('task-1');
 
       expect(result).toBe(true);
-      expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+      // On Windows, kill() is called without arguments; on Unix, kill('SIGTERM') is used
+      if (process.platform === 'win32') {
+        expect(mockProcess.kill).toHaveBeenCalled();
+      } else {
+        expect(mockProcess.kill).toHaveBeenCalledWith('SIGTERM');
+      }
       expect(manager.isRunning('task-1')).toBe(false);
     });
 

apps/frontend/src/main/agent/agent-process.ts

@@ -24,6 +24,7 @@ import type { AppSettings } from '../../shared/types/settings';
 import { getOAuthModeClearVars } from './env-utils';
 import { getAugmentedEnv } from '../env-utils';
 import { getToolInfo } from '../cli-tool-manager';
+import { isWindows } from '../platform';
 
 
 function deriveGitBashPath(gitExePath: string): string | null {
@@ -696,15 +697,39 @@ export class AgentProcessManager {
         // Mark this specific spawn as killed so its exit handler knows to ignore
         this.state.markSpawnAsKilled(agentProcess.spawnId);
 
-        // Send SIGTERM first for graceful shutdown
-        agentProcess.process.kill('SIGTERM');
-
-        // Force kill after timeout
-        setTimeout(() => {
-          if (!agentProcess.process.killed) {
-            agentProcess.process.kill('SIGKILL');
+        if (isWindows()) {
+          // Windows: .kill() then taskkill fallback
+          // SIGTERM/SIGKILL are ignored on Windows, so we use taskkill /f /t
+          try {
+            agentProcess.process.kill();
+            if (agentProcess.process.pid) {
+              const pid = agentProcess.process.pid;
+              setTimeout(() => {
+                try {
+                  // taskkill /f = force kill, /t = kill child processes tree
+                  spawn('taskkill', ['/pid', pid.toString(), '/f', '/t'], {
+                    stdio: 'ignore',
+                    detached: true
+                  }).unref();
+                } catch {
+                  // Process may already be dead
+                }
+              }, 5000);
+            }
+          } catch {
+            // Process may already be dead
           }
-        }, 5000);
+        } else {
+          // Unix: SIGTERM then SIGKILL
+          agentProcess.process.kill('SIGTERM');
+          setTimeout(() => {
+            try {
+              agentProcess.process.kill('SIGKILL');
+            } catch {
+              // Process may already be dead
+            }
+          }, 5000);
+        }
 
         this.state.deleteProcess(taskId);
         return true;
@@ -716,15 +741,39 @@ export class AgentProcessManager {
   }
 
   /**
-   * Kill all running processes
+   * Kill all running processes and wait for them to exit
    */
   async killAllProcesses(): Promise<void> {
+    const KILL_TIMEOUT_MS = 10000; // 10 seconds max wait
+
     const killPromises = this.state.getRunningTaskIds().map((taskId) => {
       return new Promise<void>((resolve) => {
+        const agentProcess = this.state.getProcess(taskId);
+
+        if (!agentProcess) {
+          resolve();
+          return;
+        }
+
+        // Set up timeout to not block forever
+        const timeoutId = setTimeout(() => {
+          resolve();
+        }, KILL_TIMEOUT_MS);
+
+        // Listen for exit event if the process supports it
+        // (process.once is available on real ChildProcess objects, but may not be in test mocks)
+        if (typeof agentProcess.process.once === 'function') {
+          agentProcess.process.once('exit', () => {
+            clearTimeout(timeoutId);
+            resolve();
+          });
+        }
+
+        // Kill the process
         this.killProcess(taskId);
-        resolve();
       });
     });
+
     await Promise.all(killPromises);
   }
 

apps/frontend/src/main/app-updater.ts

@@ -38,6 +38,9 @@ autoUpdater.autoInstallOnAppQuit = true;  // Automatically install on app quit
 // Update channels: 'latest' for stable, 'beta' for pre-release
 type UpdateChannel = 'latest' | 'beta';
 
+// Store interval ID for cleanup during shutdown
+let periodicCheckIntervalId: ReturnType<typeof setInterval> | null = null;
+
 /**
  * Set the update channel for electron-updater.
  * - 'latest': Only receive stable releases (default)
@@ -189,7 +192,7 @@ export function initializeAppUpdater(window: BrowserWindow, betaUpdates = false)
   const FOUR_HOURS = 4 * 60 * 60 * 1000;
   console.warn(`[app-updater] Periodic checks scheduled every ${FOUR_HOURS / 1000 / 60 / 60} hours`);
 
-  setInterval(() => {
+  periodicCheckIntervalId = setInterval(() => {
     console.warn('[app-updater] Performing periodic update check');
     autoUpdater.checkForUpdates().catch((error) => {
       console.error('[app-updater] ❌ Periodic update check failed:', error.message);
@@ -492,3 +495,14 @@ export async function downloadStableVersion(): Promise<void> {
     autoUpdater.allowDowngrade = false;
   }
 }
+
+/**
+ * Stop periodic update checks - called during app shutdown
+ */
+export function stopPeriodicUpdates(): void {
+  if (periodicCheckIntervalId) {
+    clearInterval(periodicCheckIntervalId);
+    periodicCheckIntervalId = null;
+    console.warn('[app-updater] Periodic update checks stopped');
+  }
+}

apps/frontend/src/main/index.ts

@@ -35,7 +35,7 @@ import { TerminalManager } from './terminal-manager';
 import { pythonEnvManager } from './python-env-manager';
 import { getUsageMonitor } from './claude-profile/usage-monitor';
 import { initializeUsageMonitorForwarding } from './ipc-handlers/terminal-handlers';
-import { initializeAppUpdater } from './app-updater';
+import { initializeAppUpdater, stopPeriodicUpdates } from './app-updater';
 import { DEFAULT_APP_SETTINGS } from '../shared/constants';
 import { readSettingsFile } from './settings-utils';
 import { setupErrorLogging } from './app-logger';
@@ -440,6 +440,9 @@ app.on('window-all-closed', () => {
 
 // Cleanup before quit
 app.on('before-quit', async () => {
+  // Stop periodic update checks
+  stopPeriodicUpdates();
+
   // Stop usage monitor
   const usageMonitor = getUsageMonitor();
   usageMonitor.stop();

apps/frontend/src/main/terminal/pty-daemon-client.ts

@@ -10,6 +10,7 @@ import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { spawn, ChildProcess } from 'child_process';
 import { app } from 'electron';
+import { isWindows } from '../platform';
 
 // ESM-compatible __dirname
 const __filename = fileURLToPath(import.meta.url);
@@ -402,6 +403,36 @@ class PtyDaemonClient {
    */
   shutdown(): void {
     this.isShuttingDown = true;
+
+    // Kill the daemon process if we spawned it
+    if (this.daemonProcess && this.daemonProcess.pid) {
+      try {
+        if (isWindows()) {
+          // Windows: use taskkill to force kill process tree
+          spawn('taskkill', ['/pid', this.daemonProcess.pid.toString(), '/f', '/t'], {
+            stdio: 'ignore',
+            detached: true
+          }).unref();
+        } else {
+          // Unix: SIGTERM then SIGKILL
+          this.daemonProcess.kill('SIGTERM');
+          const daemonProc = this.daemonProcess;
+          setTimeout(() => {
+            try {
+              if (daemonProc) {
+                daemonProc.kill('SIGKILL');
+              }
+            } catch {
+              // Process may already be dead
+            }
+          }, 2000);
+        }
+      } catch {
+        // Process may already be dead
+      }
+      this.daemonProcess = null;
+    }
+
     this.disconnect();
     this.pendingRequests.clear();
     this.dataHandlers.clear();