@mjasnikovs/pi-task 0.42.8 → 0.42.10

package/dist/shared/leftovers.d.ts

@@ -10,8 +10,11 @@ export interface Leftovers {
  * `graceMs` is POSIX's, between SIGTERM and SIGKILL. win32 has no grace to give:
  * `taskkill /F` returns once the tree is dead, and its port free (40 of 40 on the
  * windows runner).
+ *
+ * `find` is the token scan, injectable because losing a live leftover from it is
+ * what the reap has to survive — see the comment on the scan in `trackToken`.
  */
-export declare function trackLeftovers(platform: NodeJS.Platform, base: NodeJS.ProcessEnv, graceMs: number): Leftovers;
+export declare function trackLeftovers(platform: NodeJS.Platform, base: NodeJS.ProcessEnv, graceMs: number, find?: (marker: string) => number[]): Leftovers;
 /**
  * A System32 executable by absolute path, so neither PATH nor the working directory
  * can supply another. `||`, not `??`: an empty SystemRoot would make it relative.

package/dist/shared/leftovers.js

@@ -25,12 +25,16 @@ const USER_BASH_ENV = 'PI_TASK_USER_BASH_ENV';
  * `graceMs` is POSIX's, between SIGTERM and SIGKILL. win32 has no grace to give:
  * `taskkill /F` returns once the tree is dead, and its port free (40 of 40 on the
  * windows runner).
+ *
+ * `find` is the token scan, injectable because losing a live leftover from it is
+ * what the reap has to survive — see the comment on the scan in `trackToken`.
  */
-export function trackLeftovers(platform, base, graceMs) {
+export function trackLeftovers(platform, base, graceMs, find) {
     if (platform === 'win32')
         return trackShells(base);
-    if (platform === 'linux' || platform === 'darwin')
-        return trackToken(platform, base, graceMs);
+    if (platform === 'linux' || platform === 'darwin') {
+        return trackToken(platform, base, graceMs, find);
+    }
     return { env: base, reap: () => Promise.resolve() };
 }
 /**
@@ -41,30 +45,46 @@ export function system32(...segments) {
     return path.join(process.env.SystemRoot || 'C:\\Windows', 'System32', ...segments);
 }
 // ─── linux, darwin: the environment token ───────────────────────────────────
-function trackToken(platform, base, graceMs) {
+function trackToken(platform, base, graceMs, scan) {
     const token = randomUUID();
     const marker = `${LEFTOVER_TOKEN_ENV}=${token}`;
-    const find = () => platform === 'linux' ? linuxPidsWith(marker) : pidsInPsTable(darwinPsTable(), marker);
+    const defaultScan = (m) => platform === 'linux' ? linuxPidsWith(m) : pidsInPsTable(darwinPsTable(), m);
+    const find = () => (scan ?? defaultScan)(marker);
+    const endedOf = platform === 'linux' ? linuxEnded : darwinEnded;
     return {
         env: { ...base, [LEFTOVER_TOKEN_ENV]: token },
         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.
+            // Discovery stays by token, so a pid recycled mid-reap is never
+            // signalled. Liveness cannot: a dying process releases its memory —
+            // and with it the token — while it still holds its ports, so the
+            // scan reads it as gone about 9 times in 10. Each pid found is
+            // pinned to its start time and followed in the process table until
+            // that entry is reaped.
+            const held = new Map();
+            const follow = () => {
+                for (const pid of find())
+                    if (!held.has(pid))
+                        held.set(pid, hold(platform, pid));
+                for (const [pid, h] of held)
+                    if (endedOf(h))
+                        held.delete(pid);
+            };
+            follow();
+            signalEach([...held.keys()], 'SIGTERM');
+            // 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();
+                follow();
                 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)
+                if (held.size === 0 || waited >= 2 * graceMs)
                     return resolve();
                 if (!killed && waited >= graceMs) {
-                    signalEach(left, 'SIGKILL');
+                    signalEach([...held.keys()], 'SIGKILL');
                     killed = true;
                 }
                 setTimeout(poll, performance.now() - scanStart).unref();
@@ -73,6 +93,55 @@ function trackToken(platform, base, graceMs) {
         })
     };
 }
+function hold(platform, pid) {
+    const startedAt = platform === 'linux' ? linuxStartTime(pid) : darwinField(pid, 'lstart=');
+    return startedAt === undefined ? { pid } : { pid, startedAt };
+}
+/**
+ * Whether the process `held` names has ended, zombies included: a zombie has already
+ * released its ports and only waits to be reaped. A pid whose start time no longer
+ * matches belongs to someone else, so the one we held is gone.
+ */
+function linuxEnded(held) {
+    const rest = linuxStatAfterName(held.pid);
+    if (rest === null)
+        return true;
+    if (held.startedAt !== undefined && startTimeIn(rest) !== held.startedAt)
+        return true;
+    return /^[ZX]/.test(rest);
+}
+function darwinEnded(held) {
+    const state = darwinField(held.pid, 'state=');
+    if (state === undefined)
+        return true;
+    if (held.startedAt !== undefined && darwinField(held.pid, 'lstart=') !== held.startedAt) {
+        return true;
+    }
+    return state.startsWith('Z');
+}
+/** `/proc/<pid>/stat` from the state char on: the name before it can hold ') Z' itself. */
+function linuxStatAfterName(pid) {
+    try {
+        const stat = fs.readFileSync(`/proc/${pid}/stat`, 'utf8');
+        return stat.slice(stat.lastIndexOf(')') + 2);
+    }
+    catch {
+        return null;
+    }
+}
+/** starttime is stat field 22, and `rest` begins at field 3. */
+function startTimeIn(rest) {
+    return rest.split(' ')[19];
+}
+function linuxStartTime(pid) {
+    const rest = linuxStatAfterName(pid);
+    return rest === null ? undefined : startTimeIn(rest);
+}
+function darwinField(pid, field) {
+    const r = spawnSync('/bin/ps', ['-o', field, '-p', String(pid)], { encoding: 'utf8' });
+    const out = r.stdout?.trim();
+    return out ? out : undefined;
+}
 /** Pids whose environment holds `marker`, read from `<procRoot>/<pid>/environ`. */
 export function linuxPidsWith(marker, procRoot = '/proc') {
     const inner = Buffer.from(`\0${marker}\0`);

package/dist/task/command-watchdog.d.ts

@@ -32,8 +32,15 @@ import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
  * and shares the same machine from shared/command-watchdog.ts.
  */
 export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage, WATCHDOG_CANCEL_MARKER, type TimerHandle, type WatchdogDeps } from '../shared/command-watchdog.js';
-/** @internal Set by onFire when it aborts a turn. Exported for the adapter and tests. */
-export declare function noteWatchdogAbort(): void;
+/**
+ * @internal Set by onFire when it aborts a turn. Exported for the adapter and tests.
+ * Returns the previous value, which an abort that then fails must put back — the
+ * flag is shared by both watchdogs, so clearing it unconditionally would swallow a
+ * genuine abort's pending flag and leave the steer loop prompting an empty room.
+ */
+export declare function noteWatchdogAbort(): boolean;
+/** @internal Put the flag back after a noted abort did not happen. */
+export declare function restoreWatchdogAbort(was: boolean): void;
 /** True exactly once per watchdog abort; clears the flag. */
 export declare function consumeWatchdogAbort(): boolean;
 /**

package/dist/task/command-watchdog.js

@@ -1,6 +1,7 @@
 import { getConfig } from '../config/config.js';
 import { SELF_BOUNDED_TOOLS } from '../config/tool-list.js';
 import { CommandWatchdog, realTimerDeps, reminderMessage } from '../shared/command-watchdog.js';
+import { isStaleCtxError } from './stale-ctx.js';
 /**
  * MAIN-SESSION adapter for the command watchdog.
  *
@@ -53,9 +54,20 @@ export { CommandWatchdog, commandTimeoutHint, realTimerDeps, reminderMessage, WA
  * prompt.
  */
 let watchdogAbortPending = false;
-/** @internal Set by onFire when it aborts a turn. Exported for the adapter and tests. */
+/**
+ * @internal Set by onFire when it aborts a turn. Exported for the adapter and tests.
+ * Returns the previous value, which an abort that then fails must put back — the
+ * flag is shared by both watchdogs, so clearing it unconditionally would swallow a
+ * genuine abort's pending flag and leave the steer loop prompting an empty room.
+ */
 export function noteWatchdogAbort() {
+    const was = watchdogAbortPending;
     watchdogAbortPending = true;
+    return was;
+}
+/** @internal Put the flag back after a noted abort did not happen. */
+export function restoreWatchdogAbort(was) {
+    watchdogAbortPending = was;
 }
 /** True exactly once per watchdog abort; clears the flag. */
 export function consumeWatchdogAbort() {
@@ -86,10 +98,28 @@ export function registerCommandWatchdog(pi) {
             // to bound its next attempt. The flag must precede the abort so the
             // steer loop can never observe the 'aborted' turn before the flag.
             if (ctx) {
-                noteWatchdogAbort();
-                ctx.abort();
+                const wasPending = noteWatchdogAbort();
+                try {
+                    ctx.abort();
+                }
+                catch (err) {
+                    restoreWatchdogAbort(wasPending); // no turn was aborted
+                    // Timer fired after session replacement/reload: the captured ctx
+                    // is stale by design (Pi invalidates it in AgentSession.dispose).
+                    // Swallow only that guard; anything else keeps throwing, and no
+                    // follow-up is posted into the replacement session.
+                    if (!isStaleCtxError(err))
+                        throw err;
+                    return;
+                }
+            }
+            try {
+                pi.sendUserMessage(reminderMessage(toolName, timeoutMs), { deliverAs: 'followUp' });
+            }
+            catch (err) {
+                if (!isStaleCtxError(err))
+                    throw err;
             }
-            pi.sendUserMessage(reminderMessage(toolName, timeoutMs), { deliverAs: 'followUp' });
         }
     });
     pi.on('tool_execution_start', (event, ctx) => {

package/dist/task/stale-ctx.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Pi invalidates every captured ctx (and the extension's own `pi` handle) when a
+ * session is replaced or reloaded — AgentSession.dispose → ExtensionRunner.invalidate
+ * — and the guard throws from the next use. Code that fires from a TIMER rather than
+ * an event handler therefore has to expect it: the throw would otherwise escape the
+ * callback and take the host down as an uncaughtException.
+ *
+ * Matched on the message because the runtime throws a plain Error with no code or
+ * class to test. Only that one guard is swallowed; every other failure still throws.
+ */
+export declare function isStaleCtxError(err: unknown): boolean;

package/dist/task/stale-ctx.js

@@ -0,0 +1,13 @@
+/**
+ * Pi invalidates every captured ctx (and the extension's own `pi` handle) when a
+ * session is replaced or reloaded — AgentSession.dispose → ExtensionRunner.invalidate
+ * — and the guard throws from the next use. Code that fires from a TIMER rather than
+ * an event handler therefore has to expect it: the throw would otherwise escape the
+ * callback and take the host down as an uncaughtException.
+ *
+ * Matched on the message because the runtime throws a plain Error with no code or
+ * class to test. Only that one guard is swallowed; every other failure still throws.
+ */
+export function isStaleCtxError(err) {
+    return err instanceof Error && err.message.includes('stale after session');
+}

package/dist/task/stream-watchdog.js

@@ -1,6 +1,7 @@
 import { getConfig } from '../config/config.js';
 import { realStreamTimerDeps, StreamWatchdog, streamStallReminder } from '../shared/stream-watchdog.js';
-import { noteWatchdogAbort, WATCHDOG_CANCEL_MARKER } from './command-watchdog.js';
+import { noteWatchdogAbort, restoreWatchdogAbort, WATCHDOG_CANCEL_MARKER } from './command-watchdog.js';
+import { isStaleCtxError } from './stale-ctx.js';
 /**
  * MAIN-SESSION adapter for the model-stream watchdog.
  *
@@ -47,12 +48,30 @@ export function registerStreamWatchdog(pi) {
             // steer loop can otherwise observe the 'aborted' turn first and show
             // a steering prompt to an empty room, wedging an unattended run.
             if (ctx) {
-                noteWatchdogAbort();
-                ctx.abort();
+                const wasPending = noteWatchdogAbort();
+                try {
+                    ctx.abort();
+                }
+                catch (err) {
+                    restoreWatchdogAbort(wasPending); // no turn was aborted
+                    // Timer fired after session replacement/reload: the captured ctx
+                    // is stale by design (Pi invalidates it in AgentSession.dispose).
+                    // Swallow only that guard; anything else keeps throwing, and no
+                    // follow-up is posted into the replacement session.
+                    if (!isStaleCtxError(err))
+                        throw err;
+                    return;
+                }
+            }
+            try {
+                pi.sendUserMessage(streamStallReminder(idleMs, WATCHDOG_CANCEL_MARKER), {
+                    deliverAs: 'followUp'
+                });
+            }
+            catch (err) {
+                if (!isStaleCtxError(err))
+                    throw err;
             }
-            pi.sendUserMessage(streamStallReminder(idleMs, WATCHDOG_CANCEL_MARKER), {
-                deliverAs: 'followUp'
-            });
         }
     });
     // Any event proves the stream is alive. `arm` also (re)starts the machine, so

package/package.json

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