@mjasnikovs/pi-task 0.40.44 → 0.40.45

package/dist/shared/child-process.d.ts

@@ -67,7 +67,10 @@ export type OwnGroupSpawnOptions = {
  * backgrounded. Best-effort: a group already gone is not an error. Kept beside
  * the spawn shape so a platform change edits one file.
  */
-export declare function reapProcessGroup(pid: number, sig: NodeJS.Signals, platform?: NodeJS.Platform): void;
+export declare function reapProcessGroup(pid: number, sig: NodeJS.Signals, { platform, leaderExited }?: {
+    platform?: NodeJS.Platform;
+    leaderExited?: boolean;
+}): void;
 /**
  * Why runChild killed the child. Five sources converge on one kill path, and
  * each names itself here rather than in its own flag — so a consumer reads ONE

package/dist/shared/child-process.js

@@ -1,4 +1,5 @@
 import { spawn as defaultSpawn, spawnSync as spawnSyncDefault } from 'node:child_process';
+import * as path from 'node:path';
 import { realStreamTimerDeps, StreamWatchdog } from './stream-watchdog.js';
 import { realStallTimerDeps, StallProbe } from './stall-probe.js';
 import { workerChannel } from '../workers/worker-channels.js';
@@ -34,10 +35,18 @@ export function ownGroupSpawnOptions(platform) {
  * backgrounded. Best-effort: a group already gone is not an error. Kept beside
  * the spawn shape so a platform change edits one file.
  */
-export function reapProcessGroup(pid, sig, platform = process.platform) {
+export function reapProcessGroup(pid, sig, { platform = process.platform, leaderExited = false } = {}) {
+    // taskkill walks the tree down from a live leader. Once the leader has exited its
+    // pid may already be another process's, and /T /F would kill that one instead.
+    if (platform === 'win32' && leaderExited)
+        return;
     try {
         if (platform === 'win32') {
-            spawnSyncDefault('taskkill', ['/pid', String(pid), '/T', '/F']);
+            // System32's taskkill by absolute path, as pi's killProcessTree finds it, so
+            // neither PATH nor the working directory can supply another. Synchronous,
+            // unlike pi's: runChild kills the leader next, and the walk must end first.
+            const taskkill = path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'taskkill.exe');
+            spawnSyncDefault(taskkill, ['/pid', String(pid), '/T', '/F']);
         }
         else {
             process.kill(-pid, sig);
@@ -285,27 +294,29 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             proc.stdin?.end();
         }
         // Reap the child's whole process group — the child itself AND anything it
-        // backgrounded. No-op unless the child owns a group (ownGroup) and we have a pid.
+        // backgrounded.
+        let leaderExited = false;
+        proc.once('exit', () => (leaderExited = true));
         const reapGroup = (sig) => {
             if (!ownGroup || !proc.pid)
                 return;
-            reapProcessGroup(proc.pid, sig, platform);
+            reapProcessGroup(proc.pid, sig, { platform, leaderExited });
         };
         // One kill path for every source: SIGTERM, then SIGKILL after a grace
         // period if the child ignored the term. For a group-owning (model) child,
         // ALSO sweep the group so anything it backgrounded dies with it —
-        // proc.kill hits only the leader, reapGroup the grandchildren. The FIRST
-        // cause wins: a stall kill's SIGTERM can trip the abort path behind it.
+        // proc.kill hits only the leader, reapGroup the grandchildren. The sweep
+        // goes first because win32's taskkill walks the tree down from a live
+        // leader. The FIRST cause wins: a stall kill's SIGTERM can trip the abort
+        // path behind it.
         const killProc = (cause) => {
             kill ??= cause;
+            reapGroup('SIGTERM');
             proc.kill('SIGTERM');
-            if (ownGroup)
-                reapGroup('SIGTERM');
             setTimeout(() => {
+                reapGroup('SIGKILL');
                 if (!proc.killed)
                     proc.kill('SIGKILL');
-                if (ownGroup)
-                    reapGroup('SIGKILL');
             }, KILL_GRACE_MS);
         };
         // Stream watchdog (json-events children only): a silent stream is killed

package/dist/task/boot-probe.d.ts

@@ -164,8 +164,8 @@ export interface BootDeps {
      * fake pid would signal something else entirely.
      */
     killGroup?: (pid: number, signal: NodeJS.Signals) => void;
-    /** Which platform's group options to spawn with. Tests drive the win32 arm
-     *  from a POSIX host; production leaves it to `process.platform`. */
+    /** Which platform's spawn options, served-app rule and reap to use. Tests drive
+     *  the win32 arm from a POSIX host; production leaves it to `process.platform`. */
     platform?: NodeJS.Platform;
 }
 /** What `runBootCheck` passes to its spawn. */

package/dist/task/boot-probe.js

@@ -505,10 +505,6 @@ function holderIsOurs(command, boot) {
 function defaultSpawnBoot(bin, args, o) {
     return spawn(bin, args, o);
 }
-/** The real group teardown; the spawn shape's twin lives beside it. */
-function defaultKillGroup(pid, sig) {
-    reapProcessGroup(pid, sig);
-}
 /**
  * Exercise the start command ONCE. All four outcomes below were run against real
  * child processes in throwaway projects.
@@ -557,7 +553,8 @@ function defaultKillGroup(pid, sig) {
  * reports it that way — see isCommandNotFound) → skip.
  */
 export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}) {
-    const expectServer = (opts.expectServer ?? false) && process.platform !== 'win32';
+    const platform = opts.deps?.platform ?? process.platform;
+    const expectServer = (opts.expectServer ?? false) && platform !== 'win32';
     const groupHasListener = opts.deps?.groupHasListener ?? defaultGroupHasListener;
     const httpProbe = opts.deps?.httpProbe ?? defaultHttpProbe;
     const canEnumerate = expectServer ? (opts.deps?.enumerationCapable ?? canEnumerateListeners)() : true;
@@ -579,7 +576,7 @@ export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}
     return new Promise(resolve => {
         const child = spawnBoot(runner.bin, args, {
             cwd,
-            ...ownGroupSpawnOptions(opts.deps?.platform ?? process.platform),
+            ...ownGroupSpawnOptions(platform),
             stdio: ['ignore', 'pipe', 'pipe'],
             env: {
                 ...runnerEnv(runner),
@@ -612,7 +609,9 @@ export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}
                 clearInterval(poll);
             resolve(r);
         };
-        const reapGroup = opts.deps?.killGroup ?? defaultKillGroup;
+        let leaderExited = false;
+        const reapGroup = opts.deps?.killGroup
+            ?? ((pid, sig) => reapProcessGroup(pid, sig, { platform, leaderExited }));
         const killGroup = (sig) => {
             // Truthiness, deliberately: `process.kill(0, sig)` signals the
             // CALLER's own process group, so a pid of 0 turns a best-effort
@@ -725,6 +724,7 @@ export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}
         let timer = setTimeout(onGrace, graceMs);
         child.on('error', () => settle({ outcome: 'skip', spawnFailed: true }));
         child.on('exit', (status, signal) => {
+            leaderExited = true;
             if (status === 0) {
                 if (expectServer && !listenerSeen) {
                     if (!canEnumerate) {

package/dist/task/deep-render-check.js

@@ -616,6 +616,7 @@ async function drive(url, bin, userDataDir, credentials, onFacts, quietMs, signa
 export async function launchBrowser(bin, userDataDir, { signal } = {}) {
     let child = null;
     let socket = null;
+    let reaped = false;
     const close = () => {
         try {
             socket?.close();
@@ -623,8 +624,13 @@ export async function launchBrowser(bin, userDataDir, { signal } = {}) {
         catch {
             // socket already gone
         }
-        if (child?.pid)
-            reapProcessGroup(child.pid, 'SIGKILL');
+        // Once: a later pass would signal a pid the browser may have given up.
+        if (child?.pid && !reaped) {
+            reaped = true;
+            reapProcessGroup(child.pid, 'SIGKILL', {
+                leaderExited: child.exitCode !== null || child.signalCode !== null
+            });
+        }
         return Promise.resolve();
     };
     signal?.addEventListener('abort', () => void close(), { once: true });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.44",
+    "version": "0.40.45",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",