@mjasnikovs/pi-task 0.40.46 → 0.40.47

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

@@ -22,8 +22,13 @@ export interface WritableLike {
 export interface ProcLike extends EventEmitter {
     /** Present only when the child was spawned with stdin 'pipe' (prompt delivery). */
     stdin: WritableLike | null;
-    stdout: EventEmitter | null;
-    stderr: EventEmitter | null;
+    /** `destroy` is a real pipe's; a fake without one is never held open by a grandchild. */
+    stdout: (EventEmitter & {
+        destroy?: () => unknown;
+    }) | null;
+    stderr: (EventEmitter & {
+        destroy?: () => unknown;
+    }) | null;
     killed: boolean;
     /** OS pid; used to signal the child's whole process GROUP (orphan reaping). May
      *  be undefined for a mock spawn or a spawn that failed. */
@@ -82,6 +87,12 @@ export declare function reapProcessGroup(pid: number, sig: NodeJS.Signals, { pla
     platform?: NodeJS.Platform;
     leaderExited: boolean;
 }): boolean;
+/**
+ * The sweep every runner makes once its leader exited: SIGTERM the group now, and
+ * SIGKILL what ignored it after the grace. A group whose last member is gone
+ * answers ESRCH, and POSIX keeps the pgid reserved while any member lives.
+ */
+export declare function reapGroupAfterExit(pid: number, platform?: NodeJS.Platform): 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

@@ -65,6 +65,16 @@ export function reapProcessGroup(pid, sig, { platform = process.platform, leader
         return false;
     }
 }
+/**
+ * The sweep every runner makes once its leader exited: SIGTERM the group now, and
+ * SIGKILL what ignored it after the grace. A group whose last member is gone
+ * answers ESRCH, and POSIX keeps the pgid reserved while any member lives.
+ */
+export function reapGroupAfterExit(pid, platform = process.platform) {
+    if (!reapProcessGroup(pid, 'SIGTERM', { platform, leaderExited: true }))
+        return;
+    setTimeout(() => reapProcessGroup(pid, 'SIGKILL', { platform, leaderExited: true }), KILL_GRACE_MS).unref();
+}
 /** The cause a signal was aborted with, when its owner attached one. */
 function abortCause(reason) {
     const tagged = reason;
@@ -362,7 +372,14 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                     }
                 }
                 : opts;
-        const sink = sinkOpts ? new JsonEventSink(sinkOpts, hit => killProc({ by: 'loop', hit })) : null;
+        // A loop hit is the child's own verdict, not a kill from outside, so it stands
+        // even when the tail flushed after its exit is what carried it.
+        const sink = sinkOpts ?
+            new JsonEventSink(sinkOpts, hit => {
+                kill ??= { by: 'loop', hit };
+                killProc(kill);
+            })
+            : null;
         // Dead-backend stall guard (json-events children only; see the option docs).
         const stall = opts?.mode === 'json-events' ? opts.stall : undefined;
         const stallProbe = stall ?
@@ -476,8 +493,8 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             leaderExited = true;
             clearTimeout(drain);
             cleanup();
-            if (reapGroup('SIGTERM'))
-                setTimeout(() => reapGroup('SIGKILL'), KILL_GRACE_MS).unref();
+            if (ownGroup && proc.pid)
+                reapGroupAfterExit(proc.pid, platform);
             if (sink)
                 sink.flush();
             const text = sink ? sink.text : undefined;
@@ -494,11 +511,18 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                 text,
                 modelError: sink?.modelError
             };
+            // A grandchild that inherited the pipes writes into them for as long as
+            // it lives; with the read ends closed that lands nowhere.
+            proc.stdout?.destroy?.();
+            proc.stderr?.destroy?.();
             // Not settled before the leftovers are gone: the next phase needs their ports.
-            void (leftovers?.reap() ?? Promise.resolve()).then(() => settle(result));
+            const done = () => settle(result);
+            void (leftovers?.reap() ?? Promise.resolve()).then(done, done);
         };
         proc.once('error', () => {
             void leftovers?.reap();
+            proc.stdout?.destroy?.();
+            proc.stderr?.destroy?.();
             settle({
                 stdout,
                 stderr,

package/dist/shared/leftovers.d.ts

@@ -3,7 +3,7 @@ export interface Leftovers {
     /** The environment to spawn the child with. */
     env: NodeJS.ProcessEnv;
     /** End whatever the child left running. Never rejects. */
-    reap(): Promise<void>;
+    reap: () => Promise<void>;
 }
 /** Start tracking a child about to be spawned with `base` as its environment. */
 export declare function trackLeftovers(platform: NodeJS.Platform, base: NodeJS.ProcessEnv, graceMs: number): Leftovers;

package/dist/shared/leftovers.js

@@ -23,7 +23,7 @@ const USER_BASH_ENV = 'PI_TASK_USER_BASH_ENV';
 /** Start tracking a child about to be spawned with `base` as its environment. */
 export function trackLeftovers(platform, base, graceMs) {
     if (platform === 'win32')
-        return trackShells(base);
+        return trackShells(base, graceMs);
     if (platform === 'linux' || platform === 'darwin')
         return trackToken(platform, base, graceMs);
     return { env: base, reap: () => Promise.resolve() };
@@ -42,14 +42,30 @@ function trackToken(platform, base, graceMs) {
     const find = () => platform === 'linux' ? linuxPidsWith(marker) : pidsInPsTable(darwinPsTable(), marker);
     return {
         env: { ...base, [LEFTOVER_TOKEN_ENV]: token },
-        reap: () => {
-            // Found again for the SIGKILL, never remembered: a pid that died in the
-            // grace period may already be someone else's.
-            if (signalEach(find(), 'SIGTERM') > 0) {
-                setTimeout(() => signalEach(find(), 'SIGKILL'), graceMs).unref();
-            }
-            return Promise.resolve();
-        }
+        reap: () => new Promise(resolve => {
+            const started = performance.now();
+            let killed = false;
+            signalEach(find(), 'SIGTERM');
+            // Found again on every pass, never remembered: a pid that died in
+            // the grace period may already be someone else's. Each pass waits
+            // as long as the scan before it took, so the wait costs half a core
+            // at most and no invented interval.
+            const poll = () => {
+                const scanStart = performance.now();
+                const left = find();
+                const waited = performance.now() - started;
+                // A process SIGKILL cannot end (uninterruptible sleep) gets one
+                // more grace, then the run goes on without it.
+                if (left.length === 0 || waited >= 2 * graceMs)
+                    return resolve();
+                if (!killed && waited >= graceMs) {
+                    signalEach(left, 'SIGKILL');
+                    killed = true;
+                }
+                setTimeout(poll, performance.now() - scanStart).unref();
+            };
+            poll();
+        })
     };
 }
 /** Pids whose environment holds `marker`, read from `<procRoot>/<pid>/environ`. */
@@ -118,11 +134,14 @@ export const BASH_ENV_SCRIPT = [
     `if [ -n "\${${USER_BASH_ENV}:-}" ]; then . "$${USER_BASH_ENV}"; fi`,
     '__pi_task_winpid=$$',
     'if [ -r /proc/$$/winpid ]; then read -r __pi_task_winpid < /proc/$$/winpid; fi',
-    `printf 'ran %s %s\\n' "$__pi_task_winpid" "\${EPOCHREALTIME:-}" >> "$${SHELL_REGISTRY_ENV}"`,
-    `trap 'printf "exited %s %s\\n" "$__pi_task_winpid" "\${EPOCHREALTIME:-}" >> "$${SHELL_REGISTRY_ENV}"' EXIT`,
+    // EPOCHREALTIME is bash 5.0; bash 4 has whole seconds, so the run is read at
+    // the start of its second and the exit at the end of it.
+    '__pi_task_now() { if [ -n "${EPOCHREALTIME:-}" ]; then __pi_task_t=$EPOCHREALTIME; else printf -v __pi_task_t "%(%s)T" -1; __pi_task_t="$((__pi_task_t + $1)).000000"; fi; }',
+    `__pi_task_now 0; printf 'ran %s %s\\n' "$__pi_task_winpid" "$__pi_task_t" >> "$${SHELL_REGISTRY_ENV}"`,
+    `trap '__pi_task_now 1; printf "exited %s %s\\n" "$__pi_task_winpid" "$__pi_task_t" >> "$${SHELL_REGISTRY_ENV}"' EXIT`,
     ''
 ].join('\n');
-function trackShells(base) {
+function trackShells(base, graceMs) {
     let dir;
     try {
         dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pi-task-shells-'));
@@ -146,15 +165,19 @@ function trackShells(base) {
                 const shells = parseShells(fs.existsSync(registry) ? fs.readFileSync(registry, 'utf8') : '');
                 if (shells.length === 0)
                     return;
-                const started = startedByShells(parseProcessTable(await processTable()), shells);
+                const table = await processTable(graceMs);
+                const started = startedByShells(parseProcessTable(table), shells);
                 await Promise.all(started.map(taskkillTree));
             }
             catch {
                 // best-effort, like every other reap
             }
-            finally {
+            try {
                 fs.rmSync(dir, { recursive: true, force: true });
             }
+            catch {
+                // a handle still open in there; the run must not wait on it
+            }
         }
     };
 }
@@ -214,16 +237,23 @@ export function parseProcessTable(text) {
     }
     return rows;
 }
-/** Every process as `pid ppid creation-FILETIME`, one per line. */
-function processTable() {
+/**
+ * Every process as `pid ppid creation-FILETIME`, one per line. A CIM query that
+ * has not answered within the kill grace is given up on: the run is waiting.
+ */
+function processTable(graceMs) {
     const query = 'Get-CimInstance Win32_Process -Property ProcessId,ParentProcessId,CreationDate'
         + ' | ForEach-Object { "$($_.ProcessId) $($_.ParentProcessId) $($_.CreationDate.ToFileTimeUtc())" }';
     return new Promise(resolve => {
         let out = '';
         const ps = spawn(system32('WindowsPowerShell', 'v1.0', 'powershell.exe'), ['-NoProfile', '-NonInteractive', '-Command', query], { stdio: ['ignore', 'pipe', 'ignore'] });
+        const giveUp = setTimeout(() => ps.kill(), graceMs);
         ps.stdout.on('data', (d) => (out += d.toString()));
         ps.on('error', () => resolve(''));
-        ps.on('close', () => resolve(out));
+        ps.on('close', () => {
+            clearTimeout(giveUp);
+            resolve(out);
+        });
     });
 }
 function taskkillTree(pid) {

package/dist/task/command-run.js

@@ -29,7 +29,7 @@
  * the gate's boot half, while its command half had none.
  */
 import { spawn } from 'node:child_process';
-import { EXIT_DRAIN_MS } from '../shared/child-process.js';
+import { EXIT_DRAIN_MS, ownGroupSpawnOptions, reapGroupAfterExit, reapProcessGroup } from '../shared/child-process.js';
 import { isCommandNotFound, resolveRunner, runnerEnv } from './runner-resolve.js';
 /**
  * How much of ONE stream may be held in the HOST process, and how it is split.
@@ -97,6 +97,8 @@ export const spawnCommand = spec => new Promise(resolve => {
     let exited = false;
     let endedStreams = 0;
     let drain;
+    // Its own process group: a pretest that backgrounds a daemon, a build that
+    // leaves a watcher, would otherwise hold their ports into the boot check.
     const child = spawn(spec.bin, spec.args, {
         cwd: spec.cwd,
         // stdin CLOSED. `spawnSync` gave the child none; the default `spawn`
@@ -104,6 +106,7 @@ export const spawnCommand = spec => new Promise(resolve => {
         // a `cat`-style pipeline, a tool that prompts, a pager — would block
         // until the kill timer fires instead of returning at once.
         stdio: ['ignore', 'pipe', 'pipe'],
+        ...ownGroupSpawnOptions(process.platform),
         ...(spec.env ? { env: spec.env } : {})
     });
     const done = (status, failure) => {
@@ -127,6 +130,8 @@ export const spawnCommand = spec => new Promise(resolve => {
             done(exitStatus);
     };
     const kill = () => {
+        if (child.pid)
+            reapProcessGroup(child.pid, 'SIGKILL', { leaderExited: exited });
         try {
             child.kill('SIGKILL');
         }
@@ -135,9 +140,9 @@ export const spawnCommand = spec => new Promise(resolve => {
         }
     };
     /**
-     * The deadline and the cancel both END the run. The kill only reaches the
-     * direct child, so this cannot wait to observe its effect — it kills, gives
-     * the pipes one drain, and reports `status: null` regardless.
+     * The deadline and the cancel both END the run. This cannot wait to observe
+     * the kill's effect — it kills, gives the pipes one drain, and reports
+     * `status: null` regardless.
      */
     const killAndSettle = () => {
         kill();
@@ -171,6 +176,8 @@ export const spawnCommand = spec => new Promise(resolve => {
     child.on('exit', (code) => {
         exited = true;
         exitStatus = code;
+        if (child.pid)
+            reapGroupAfterExit(child.pid);
         // Both ends of the same question: settle now if the pipes are already
         // at EOF, otherwise settle after one short drain rather than waiting on
         // whoever else is holding them.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.40.46",
+    "version": "0.40.47",
     "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",