fix(lifecycle): use process group kill (-pid) in handleExit safety net

With detached:true children, the synchronous exit handler must kill
the entire process group, not just the direct PID.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@push.rocks/smartexit",
-  "version": "2.0.0",
+  "version": "2.0.2",
   "private": false,
   "description": "A library for managing graceful shutdowns of Node.js processes by handling cleanup operations, including terminating child processes.",
   "main": "dist_ts/index.js",

ts/smartexit.classes.lifecycle.ts

@@ -187,21 +187,24 @@ export class ProcessLifecycle {
     });
   }
 
-  /** Synchronous last-resort: SIGKILL any remaining child processes. */
+  /** Synchronous last-resort: SIGKILL any remaining tracked process groups. */
   private handleExit(): void {
     const instances = ProcessLifecycle.getInstances();
     let killed = 0;
 
     for (const instance of instances) {
-      const processes = instance.processesToEnd.getArray();
-      for (const child of processes) {
-        const pid = child.pid;
-        if (pid && !child.killed) {
+      for (const pid of instance.trackedPids) {
+        // Kill entire process group (negative PID) for detached children
+        try {
+          process.kill(-pid, 'SIGKILL');
+          killed++;
+        } catch {
+          // Process group may not exist, try single PID
           try {
             process.kill(pid, 'SIGKILL');
             killed++;
           } catch {
-            // Process may already be dead
+            // Process already dead
           }
         }
       }

ts/smartexit.classes.smartexit.ts

@@ -70,6 +70,8 @@ export class SmartExit {
   // Instance state
   public processesToEnd = new plugins.lik.ObjectMap<plugins.childProcess.ChildProcess>();
   public cleanupFunctions = new plugins.lik.ObjectMap<() => Promise<any>>();
+  /** PIDs tracked independently — survives removeProcess() so shutdown can still kill the tree. */
+  public trackedPids = new Set<number>();
   private options: ISmartExitOptions;
 
   private log(message: string, isError = false): void {
@@ -93,6 +95,9 @@ export class SmartExit {
   /** Register a child process for cleanup on shutdown. */
   public addProcess(childProcessArg: plugins.childProcess.ChildProcess) {
     this.processesToEnd.add(childProcessArg);
+    if (childProcessArg.pid) {
+      this.trackedPids.add(childProcessArg.pid);
+    }
   }
 
   /** Register an async cleanup function to run on shutdown. */
@@ -126,23 +131,25 @@ export class SmartExit {
       }
     }
 
-    // Phase 2: Kill child process trees
-    for (const childProcessArg of processes) {
-      const pid = childProcessArg.pid;
-      if (pid && !childProcessArg.killed) {
-        try {
-          await SmartExit.killTreeByPid(pid, 'SIGTERM');
-        } catch {
-          // SIGTERM failed — force kill
-          try {
-            await SmartExit.killTreeByPid(pid, 'SIGKILL');
-          } catch {
-            // Process may already be dead
-          }
-        }
+    // Phase 2: Kill ALL tracked process trees by PID.
+    // We use trackedPids (not processesToEnd) because the process object may have
+    // been removed by smartshell's exit handler before shutdown runs.
+    // We do NOT check .killed — the direct child may be dead but grandchildren alive.
+    for (const pid of this.trackedPids) {
+      try {
+        await SmartExit.killTreeByPid(pid, 'SIGTERM');
         processesKilled++;
+      } catch {
+        // SIGTERM failed — force kill
+        try {
+          await SmartExit.killTreeByPid(pid, 'SIGKILL');
+          processesKilled++;
+        } catch {
+          // Process tree already dead — fine
+        }
       }
     }
+    this.trackedPids.clear();
 
     return { processesKilled, cleanupFunctionsRan };
   }