@mjasnikovs/pi-task 0.42.7 → 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/deferred-breakage.js

@@ -21,22 +21,37 @@
 const TEST_NOUN = /\b(?:tests?|suites?|assertions?)\b/i;
 const BUILD_NOUN = /\b(?:lint|linter|typecheck|build|ci)\b/i;
 const FAILURE = /\b(?:fail\w*|red|broken|breaks?|breakage|errors?)\b/i;
-/** Before a phrase in its clause: the phrase is rejected. */
-const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather than|instead of|isn't|is not|without|avoid|avoiding)\b/i;
+/** Before a phrase in its clause: the phrase is rejected. Models emit U+2019 as
+ *  readily as ASCII, so a contraction must not turn the verdict on the character. */
+const NOT_A_DECISION = /\b(?:not|never|no|do(?:es)?n['’]t|do(?:es)? not|won['’]t|will not|wouldn['’]t|would not|rather than|instead of|isn['’]t|is not|without|avoid|avoiding)\b/i;
 /**
- * A modal cancels a phrase only where the sentence poses an option for it to
- * weigh: "IF NOT EXISTS would still leave the test failing" describes what a
- * rejected option does. A bare hedge does not — "I would flag it as a known
- * issue" is the decision, and treating every modal as hypothetical let the guard
- * be rephrased away.
+ * A modal cancels a phrase only where the sentence is weighing something: "IF NOT
+ * EXISTS would still leave the test failing" describes what a rejected option
+ * does. A bare hedge does not — "I would flag it as a known issue" is the
+ * decision, and treating every modal as hypothetical let the guard be rephrased
+ * away.
  */
 const MODAL = /\b(?:would|could|might)\b/i;
-/** A condition governs its own half of a semicolon and reaches no further. */
+/** A condition governs the clauses it opens and stops at the conclusion drawn. */
 const CONDITION = /\b(?:if|unless)\b/i;
-/** Options are posed once and weighed in any later clause of the sentence. */
-const OPTION = /\b(?:either|whether|option|alternative|otherwise)\b/i;
-/** Whatever the sentence weighs, "I would …" is the answer's own decision. */
+/** Options are posed once and weighed anywhere in the sentence. */
+const OPTION = /\b(?:either|whether|options?|alternatives?|otherwise)\b/i;
+/** Under a condition the subject says whose modal it is: "the latter would leave
+ *  it red" is the option behaving, "I would leave it red" is the answer deciding. */
 const FIRST_PERSON = /\b(?:i|we)\s+(?:would|could|might)\b/i;
+/**
+ * The repair the sentence goes on to choose. An option's consequence is a
+ * hypothesis only where the sentence chooses against it; a deferral that nothing
+ * overrules is the decision, however the sentence hedges it. Checking for the
+ * choice rather than for a pronoun is what stops "it could be left failing for
+ * whoever owns it" from riding out on one option word.
+ */
+const CHOOSES_REPAIR = /\b(?:i|we)(?:\s+will|\s+shall|['’]ll)\s+(?:update|fix|change|add|adjust|amend|correct)\b|\bso\s+(?:update|fix|change|adjust|amend|correct)\b/i;
+/** Where a hypothesis's reach ends: a semicolon starts an independent clause, and
+ *  "so" introduces the conclusion drawn, not another branch of the hypothesis.
+ *  Neither is a comma, which is why scoping a condition by punctuation alone let
+ *  "fails only if X, so it could be flagged as known" through. */
+const HYPOTHESIS_END = /;|\bso\b|\btherefore\b|\bhence\b|\bthus\b/i;
 /** Where one clause ends and the next begins. A semicolon joins clauses of ONE
  *  thought, so the breakage a clause defers may sit in the other half. */
 const CLAUSE_BOUNDARY = /[,:;()]|\s[—–-]\s|\b(?:and|but|so|then|while|whereas|although|though|because|since|however)\b/gi;
@@ -59,11 +74,15 @@ const PHRASES = [
     // Handing the work to an unnamed someone is the deferral itself, whatever the
     // clause is about; bare `whoever` below still needs a check to be one.
     { re: /\bwhoever\s+(?:owns|revisits|maintains|touches)\b/i, needs: 'alone' },
-    // Ownership handed to a ROLE is handed to nobody: no release manager exists in
-    // a /task-auto run. A named team is someone, so the lookahead hands those to
-    // the `check` rule below rather than listing every job title here.
+    // Ownership handed to a ROLE is handed to nobody: no release manager, QA or
+    // on-call engineer sits in a /task-auto run. Anyone else the answer names — a
+    // person, a team, the runner, this task — is ownership TAKEN, so the phrase
+    // alone is not the deferral. The list names the nobodies rather than exempting
+    // the somebodies, because the two misses cost differently: a role it does not
+    // know still reaches the `check` rule below, while a somebody it mistakes for
+    // nobody destroys the answer this guard exists to protect.
     {
-        re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b(?!.*\b(?:teams?|groups?|squads?|guilds?|crews?)\b)/i,
+        re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\s+(?:whoever|someone|somebody|anyone|another\b|a\s+(?:later|future|separate)\b|(?:the\s+)?(?:release\s+manager|on[- ]call|qa|sre)\b|the\s+(?:\w+\s+)?(?:owners?|maintainers?)\b)/i,
         needs: 'alone'
     },
     { re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'check' },
@@ -89,10 +108,12 @@ function aboutACheck(text) {
 /**
  * Parenthetical asides go, and a code span keeps its words but loses the
  * punctuation that would split a clause in two: `toEqual([{filename: X}])` is
- * one token of the sentence around it, not three clauses.
+ * one token of the sentence around it, not three clauses. Brackets close up
+ * instead of spacing, because a bracket binds to what it encloses — spacing
+ * `arr[i]` leaves a bare `i` for the first-person rule to read as a pronoun.
  */
 function prose(answer) {
-    let text = answer.replace(/`([^`]*)`/g, (_m, code) => code.replace(/[,;:()[\]{}]/g, ' '));
+    let text = answer.replace(/`([^`]*)`/g, (_m, code) => code.replace(/[[\]{}]/g, '').replace(/[,;:()]/g, ' '));
     let before;
     do {
         before = text;
@@ -106,13 +127,16 @@ function clauses(sentence) {
 export function defersBreakage(answer) {
     for (const sentence of prose(answer).split(SENTENCE_BOUNDARY)) {
         const sentenceBreaks = aboutACheck(sentence) && FAILURE.test(sentence);
-        const posesOptions = OPTION.test(sentence);
-        // A semicolon joins two independent clauses, so "the test fails only if X;
-        // it could be flagged as known" states a condition and then decides. The
-        // options the sentence posed reach across it; the condition does not.
-        for (const half of sentence.split(';')) {
-            const weighsOptions = posesOptions || CONDITION.test(half);
-            for (const clause of clauses(half)) {
+        const weighsRejectedOption = OPTION.test(sentence) && CHOOSES_REPAIR.test(sentence);
+        const cancelsModal = (before, underCondition) => (underCondition && !FIRST_PERSON.test(before)) || weighsRejectedOption;
+        // A condition governs the clauses it opens and stops at the conclusion the
+        // sentence draws, so "fails only if the fixture is stale, so it could be
+        // flagged as known" states a condition and then decides. An option is posed
+        // once and weighed anywhere, but only where the sentence goes on to pick a
+        // repair is the modal describing the branch it rejected.
+        for (const segment of sentence.split(HYPOTHESIS_END)) {
+            const underCondition = CONDITION.test(segment);
+            for (const clause of clauses(segment)) {
                 for (const { re, needs } of PHRASES) {
                     const hit = re.exec(clause);
                     if (!hit)
@@ -120,7 +144,7 @@ export function defersBreakage(answer) {
                     const before = clause.slice(0, hit.index);
                     if (NOT_A_DECISION.test(before))
                         continue;
-                    if (MODAL.test(before) && weighsOptions && !FIRST_PERSON.test(before))
+                    if (MODAL.test(before) && cancelsModal(before, underCondition))
                         continue;
                     if (needs === 'check' && !aboutACheck(clause))
                         continue;

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