@mjasnikovs/pi-task 0.42.8 → 0.42.9

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.9",
     "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",