@link-assistant/hive-mind 1.45.0 → 1.45.1

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @link-assistant/hive-mind
 
+## 1.45.1
+
+### Patch Changes
+
+- 003c5ca: Fix premature finish signaling and leaked child processes (Issue #1516)
+  - Kill entire process group on stream timeout using negative PID, preventing leaked /bin/sh child processes from continuing to make commits after completion
+  - Move .gitkeep cleanup to after all completion signals (log upload, "Ready to merge" comment) so no new commits appear after the system reports "session ended"
+  - drainHandles now reports surviving child processes as errors instead of silently killing them, so root causes are investigated rather than hidden
+
 ## 1.45.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@link-assistant/hive-mind",
-  "version": "1.45.0",
+  "version": "1.45.1",
   "description": "AI-powered issue solver and hive mind for collaborative problem solving",
   "main": "src/hive.mjs",
   "type": "module",

package/src/claude.lib.mjs

@@ -852,22 +852,22 @@ export const executeClaudeCommand = async params => {
       let lastEventTime = null;
       let activityTimeoutId = null;
       let isActivityTimeout = false;
-      // Issue #1510: Separate SIGTERM (graceful) and SIGKILL (force) phases to allow
-      // capturing final output from the process during graceful shutdown
+      // Issue #1516: Kill process group (-pid) so leaked /bin/sh children don't survive
+      // prettier-ignore
+      const killProcessTree = signal => { try { const pid = execCommand.pid || execCommand._pid; if (pid) { process.kill(-pid, signal); return; } } catch { /* not group leader */ } execCommand.kill(signal); };
       const forceExitOnTimeout = async () => {
         if (forceExitTriggered) return;
         forceExitTriggered = true;
-        await log(`⚠️ Stream timeout — sending SIGTERM for graceful shutdown (Issue #1280, #1510)`, { verbose: true });
+        await log(`⚠️ Stream timeout — sending SIGTERM for graceful shutdown (Issue #1280, #1510, #1516)`, { verbose: true });
         try {
           if (execCommand.kill) {
-            execCommand.kill('SIGTERM');
+            killProcessTree('SIGTERM');
             // Issue #1346/#1510: Follow up with SIGKILL after 5s if still alive
-            // Increased from 2s to 5s to give more time for final output capture
             const t = setTimeout(() => {
               try {
                 if (!execCommand.result?.code) {
-                  log(`⚠️ Process did not exit after SIGTERM, sending SIGKILL`, { verbose: true });
-                  execCommand.kill('SIGKILL');
+                  log(`⚠️ Process tree did not exit after SIGTERM, sending SIGKILL (Issue #1516)`, { verbose: true });
+                  killProcessTree('SIGKILL');
                 }
               } catch {
                 /* exited */

package/src/exit-handler.lib.mjs

@@ -121,12 +121,30 @@ const drainHandles = async () => {
     // undici may not be available in all Node versions — safe to ignore
   }
 
-  // 3. Unref surviving child processes from command-stream.
-  //    These are typically already-exited but their OS handle entry lingers.
+  // 3. Detect surviving child processes from command-stream.
+  //    Issue #1516: Surviving ChildProcess handles indicate a bug — a leaked /bin/sh
+  //    child can continue executing (making commits, pushing to GitHub) after we've
+  //    declared completion. Instead of silently killing them (which hides root causes),
+  //    we log an error so each occurrence is investigated and the root cause is fixed.
+  //    The process group kill in claude.lib.mjs (killProcessTree) should have already
+  //    terminated all children; if any survive, that's a bug we need to know about.
   try {
     for (const handle of process._getActiveHandles()) {
-      if (handle?.constructor?.name === 'ChildProcess' && typeof handle.unref === 'function') {
-        handle.unref();
+      if (handle?.constructor?.name === 'ChildProcess') {
+        // Issue #1516: Report surviving child processes as errors instead of killing them.
+        // This surfaces the root cause for investigation rather than hiding it.
+        const detail = [handle.pid != null ? `pid=${handle.pid}` : null, handle.spawnfile ? `file=${handle.spawnfile}` : null, handle.killed ? 'killed=true' : 'killed=false'].filter(Boolean).join(', ');
+        const errorMsg = `❌ ERROR: Surviving ChildProcess detected at exit (${detail}). This indicates a leaked process that was not properly terminated. Investigate the root cause — do NOT suppress this error by killing the process. (Issue #1516)`;
+        if (logFunction) {
+          await logFunction(errorMsg, { level: 'error' });
+        } else {
+          console.error(errorMsg);
+        }
+        // Still unref so Node.js can exit, but do NOT kill — let the OS process
+        // continue so its effects are visible and the root cause can be diagnosed.
+        if (typeof handle.unref === 'function') {
+          handle.unref();
+        }
       }
     }
   } catch {

package/src/solve.mjs

@@ -1175,8 +1175,7 @@ try {
   const autoRestartEnabled = argv['autoRestartOnUncommittedChanges'] !== false;
   const shouldRestart = await checkForUncommittedChanges(tempDir, owner, repo, branchName, $, log, shouldAutoCommit, autoRestartEnabled);
 
-  // Remove initial commit file (CLAUDE.md or .gitkeep) now that Claude command has finished
-  await cleanupClaudeFile(tempDir, branchName, claudeCommitHash, argv);
+  // Issue #1516: cleanupClaudeFile() moved to after completion signals (before endWorkSession)
 
   // Show summary of session and log file
   await showSessionSummary(sessionId, limitReached, argv, issueUrl, tempDir, shouldAttachLogs);
@@ -1442,6 +1441,9 @@ try {
     }
   }
 
+  // Issue #1516: Cleanup after all signals (was before verifyResults, caused premature commits)
+  await cleanupClaudeFile(tempDir, branchName, claudeCommitHash, argv);
+
   // End work session using the new module
   await endWorkSession({
     isContinueMode,