@mjasnikovs/pi-task 0.40.40 → 0.40.42

package/dist/task/enforce-guidelines.d.ts

@@ -1,5 +1,5 @@
 import type { SpawnFn } from '../shared/child-process.js';
-import { type WorkerFailureInput } from '../workers/worker-failure.js';
+import { type WorkerAnswerInput, type WorkerFailureInput } from '../workers/worker-failure.js';
 /** Filenames discovered in the working directory (cwd only — no tree walk). */
 export declare const GUIDELINE_FILENAMES: readonly ["AGENTS.md", "CLAUDE.md"];
 /**
@@ -94,8 +94,7 @@ export declare function parseEnforceVerdict(text: string): {
     detail: string;
 };
 /** The subset of a runWorker result the enforcement-child mapping reads. */
-export interface EnforceChildResult extends WorkerFailureInput {
-    text: string;
+export interface EnforceChildResult extends WorkerFailureInput, WorkerAnswerInput {
 }
 /**
  * Map the enforcement child's runWorker result to a fatal error message, or null
@@ -114,11 +113,16 @@ export interface EnforceChildResult extends WorkerFailureInput {
  * user as their own cancel. The switch below is exhaustive, so the next cause
  * added to the union is a compile error here rather than a silent mislabel.
  *
- * A loop is NOT fatal: enforce attaches the detector in nudge-then-warn mode, so a
- * loop that survived its restart-with-hint nudges returns null here (the caller
- * logs/notifies it as a warning) and the verdict gate alone decides the outcome.
- * It still has to be matched before `aborted`/`exitCode` so the kill's side
- * effects don't get re-classified as a user cancel or a crash.
+ * A loop is NOT fatal on its own: enforce attaches the detector in nudge-then-warn
+ * mode, so a loop that survived its restart-with-hint nudges is a warning (the
+ * caller notifies it) and the answer still decides. It still has to be matched
+ * before `aborted`/`exitCode` so the kill's side effects don't get re-classified
+ * as a user cancel or a crash.
+ *
+ * After the kill ladder, the answer itself: a model error or a child that never
+ * spoke is fatal — left unread, either parses as "no verdict" and a dead provider
+ * is blamed on the work (issue #19). Only a genuinely empty answer reaches the
+ * verdict parser.
  */
 export declare function classifyEnforceChildFailure(r: EnforceChildResult): string | null;
 /**

package/dist/task/enforce-guidelines.js

@@ -25,7 +25,7 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { makeGit } from '../shared/git-runner.js';
 import { USER_CANCELLED } from './child-runner.js';
-import { classifyWorkerFailure } from '../workers/worker-failure.js';
+import { classifyWorkerAnswer, classifyWorkerFailure, describeNoAnswer } from '../workers/worker-failure.js';
 import { TASKS_DIR_NAME } from './task-types.js';
 import { findProbeGamingInDiff } from './probe-gaming.js';
 /** Filenames discovered in the working directory (cwd only — no tree walk). */
@@ -229,16 +229,28 @@ export function parseEnforceVerdict(text) {
  * user as their own cancel. The switch below is exhaustive, so the next cause
  * added to the union is a compile error here rather than a silent mislabel.
  *
- * A loop is NOT fatal: enforce attaches the detector in nudge-then-warn mode, so a
- * loop that survived its restart-with-hint nudges returns null here (the caller
- * logs/notifies it as a warning) and the verdict gate alone decides the outcome.
- * It still has to be matched before `aborted`/`exitCode` so the kill's side
- * effects don't get re-classified as a user cancel or a crash.
+ * A loop is NOT fatal on its own: enforce attaches the detector in nudge-then-warn
+ * mode, so a loop that survived its restart-with-hint nudges is a warning (the
+ * caller notifies it) and the answer still decides. It still has to be matched
+ * before `aborted`/`exitCode` so the kill's side effects don't get re-classified
+ * as a user cancel or a crash.
+ *
+ * After the kill ladder, the answer itself: a model error or a child that never
+ * spoke is fatal — left unread, either parses as "no verdict" and a dead provider
+ * is blamed on the work (issue #19). Only a genuinely empty answer reaches the
+ * verdict parser.
  */
 export function classifyEnforceChildFailure(r) {
-    const failure = classifyWorkerFailure(r);
-    if (!failure)
+    const kill = classifyWorkerFailure(r);
+    const named = kill ? describeKill(kill) : null;
+    if (named !== null)
+        return named;
+    const noAnswer = classifyWorkerAnswer(r);
+    if (!noAnswer || noAnswer.kind === 'empty-answer')
         return null;
+    return describeNoAnswer(noAnswer);
+}
+function describeKill(failure) {
     switch (failure.kind) {
         case 'stalled':
             // Otherwise a long silence is reported as a user cancel.

package/dist/task/final-gate-fix.js

@@ -199,8 +199,8 @@ export async function runFinalGateAutofix(deps) {
         signal: deps.signal,
         marker: 'FINAL-GATE-FIX'
     });
-    if (end.kind === 'error')
-        return { ok: false, reason: `fix child failed: ${end.msg}` };
+    // A child that threw is NOT an early return from here: the guards below catch
+    // what it wrote before it died, and a thrown child has still written it.
     // What the child wrote to gitignored paths. Recorded on the trail IMMEDIATELY —
     // before any guard can reject the attempt — because `discard` reverts tracked
     // edits only: an ignored file the pass wrote survives a rejection, and the trail
@@ -300,6 +300,9 @@ export async function runFinalGateAutofix(deps) {
             return r;
         }
     }
+    if (end.kind === 'error') {
+        return withIgnored({ ok: false, reason: `fix child failed: ${end.msg}` });
+    }
     if (end.kind === 'blocked') {
         // Self-declared blocked: skip the (expensive) gate re-run; nothing converged.
         return withIgnored({ ok: false, reason: `fix child blocked: ${end.note}` });

package/dist/task/gate-child.js

@@ -152,15 +152,16 @@ export function makeGateChild(deps) {
                     }
                 }
             }
+            const failure = classifyEnforceChildFailure(r);
             // A loop that survived the restart-with-hint nudges is a WARNING, not a
             // failure: log it and tell the user, but let the verdict gate be the
-            // only thing that can block.
-            if (r.loopHit) {
+            // only thing that can block. Unless the same child also failed — then
+            // "continuing" would contradict the throw below.
+            if (r.loopHit && failure === null) {
                 log(`=== ${deps.kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
                 notifyRun(deps.ctx, `${deps.taskTitle}: ${deps.kind} worker looped past the nudges — `
                     + 'continuing (not blocked).', 'warning');
             }
-            const failure = classifyEnforceChildFailure(r);
             log(failure ?
                 `=== ${deps.kind} end: FAIL — ${failure} ===`
                 : `=== ${deps.kind} end: ${row.okMarker} ===`);

package/dist/task/lint-fix.js

@@ -219,14 +219,9 @@ export async function runBoundedLintFix(deps) {
         signal: deps.signal,
         marker: 'LINT-FIX'
     });
-    if (end.kind === 'error') {
-        deps.log?.(`lint-fix child failed — ${end.msg}`);
-        return { ok: false, reason: `fix child failed: ${end.msg}` };
-    }
-    // A BLOCKED child is NOT an early return from here: the guards below exist to
-    // catch a child that discarded work, and a child can discard work and then
-    // block. The marker is consulted after them, in place of the re-run — which is
-    // where the twin consults its own.
+    // Neither a BLOCKED nor a thrown child is an early return from here: the
+    // guards below exist to catch a child that discarded work, and a child can
+    // discard work and then block, or die. Both are consulted after them.
     // REVERT-GUARD: every pre-existing work file must still differ from HEAD, and
     // every pre-existing untracked file must still exist. Trip → restore snapshot.
     // Every comparison requires git to have actually SUCCEEDED. A git error after
@@ -325,6 +320,10 @@ export async function runBoundedLintFix(deps) {
             }
         }
     }
+    if (end.kind === 'error') {
+        deps.log?.(`lint-fix child failed — ${end.msg}`);
+        return { ok: false, reason: `fix child failed: ${end.msg}` };
+    }
     if (end.kind === 'blocked')
         deps.log?.(`lint-fix BLOCKED — ${end.note}`);
     // The CHECK is the arbiter, including after a BLOCKED marker.

package/dist/task/verify-work.js

@@ -37,6 +37,7 @@
  * can FAIL before the spec is looked at.
  */
 import { USER_CANCELLED } from './child-runner.js';
+import { isModelErrorMessage } from '../workers/worker-failure.js';
 import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from './env-notes.js';
 import { buildContractsVerifyBlock } from './contracts.js';
 import { findSkipEscapes, skipEscapeVerifyFindings } from './skip-escape.js';
@@ -823,6 +824,9 @@ export async function runWorkVerification(deps) {
             if (err instanceof Error && err.message === USER_CANCELLED)
                 throw err;
             const msg = err instanceof Error ? err.message : String(err);
+            // A provider that died under the child never judged the work either.
+            if (isModelErrorMessage(msg) && attempt === 1)
+                continue;
             return {
                 ok: false,
                 failClass: 'harness-fault',

package/dist/workers/pi-worker-core.d.ts

@@ -272,8 +272,9 @@ export interface RunWorkerResult {
      * surface this through child-runner.ts; without it a swallowed provider error
      * reaches the caller as an indistinguishable empty answer and gets reported as
      * the useless "produced no output".
-     * Only meaningful when `text` is empty: a turn that produced text after pi
-     * recovered is a success, and the first-error capture must not relabel it.
+     * Survives next to text only when the error came AFTER that text: a turn
+     * that produced text after pi recovered is a success and the sink drops the
+     * earlier error. See `classifyWorkerAnswer` (worker-failure.ts).
      */
     modelError?: string;
     /**

package/dist/workers/pi-worker.d.ts

@@ -12,4 +12,10 @@
  * — the tool whitelist, not the extension flag, is the bound that holds.
  */
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
-export declare function registerPiWorker(pi: ExtensionAPI): void;
+import type { SpawnFn } from '../shared/child-process.js';
+/** Test seams: a fake child, and no real backoff sleep between its attempts. */
+export interface PiWorkerInternals {
+    spawn?: SpawnFn;
+    sleepFor?: (ms: number) => Promise<void>;
+}
+export declare function registerPiWorker(pi: ExtensionAPI, internals?: PiWorkerInternals): void;

package/dist/workers/pi-worker.js

@@ -17,12 +17,34 @@ import { getConfig } from '../config/config.js';
 import { groupChildArgs } from '../config/group-args.js';
 import { runWorker } from './pi-worker-core.js';
 import { contextWindowForGroup } from '../task/context-usage.js';
+import { classifyWorkerAnswer, describeNoAnswer } from './worker-failure.js';
 import { childFailureReason, formatChildFailure, makeWorkerTool, workerAnswer, workerUnavailable } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
+const STDERR_TAIL = 500;
+function workerDetails(r) {
+    return {
+        exitCode: r.exitCode,
+        attempts: r.attempts,
+        restarts: r.restarts.map(x => ({
+            reason: x.reason,
+            ...(x.detail !== undefined ? { detail: x.detail } : {})
+        })),
+        ...(r.modelError !== undefined ? { modelError: r.modelError } : {}),
+        ...(r.stderr ? { stderr: r.stderr.slice(-STDERR_TAIL) } : {})
+    };
+}
+/** An empty final answer, with the spawns it cost, so the model can tell a
+ *  retried failure from a child that simply had nothing to say. */
+function describeEmptyAnswer(r) {
+    if (r.restarts.length === 0)
+        return '(no output)';
+    const reasons = r.restarts.map(x => x.reason).join(', ');
+    return `(no output after ${r.attempts} attempts; discarded: ${reasons})`;
+}
 const WorkerParams = Type.Object({
     prompt: Type.String({ description: 'Task for the worker to perform.' })
 });
-export function registerPiWorker(pi) {
+export function registerPiWorker(pi, internals = {}) {
     makeWorkerTool(pi, {
         name: 'pi-worker',
         label: 'Pi Worker',
@@ -67,14 +89,24 @@ export function registerPiWorker(pi) {
                 // model and its window is the honest one. Without this the churn
                 // rule cannot fire — see RunWorkerInput.contextWindow.
                 contextWindow: contextWindowForGroup(ctx, 'research') || 'unknown',
-                groupArgs: groupChildArgs('research')
+                groupArgs: groupChildArgs('research'),
+                ...(internals.spawn ? { spawn: internals.spawn } : {}),
+                ...(internals.sleepFor ? { sleepFor: internals.sleepFor } : {})
             });
-            const details = { exitCode: result.exitCode };
+            const details = workerDetails(result);
             const failure = formatChildFailure(result, 'Worker aborted.');
             if (failure !== null) {
                 return workerUnavailable(failure, details, childFailureReason(result));
             }
-            return workerAnswer(result.text || '(no output)', details);
+            const noAnswer = classifyWorkerAnswer(result);
+            if (noAnswer === undefined)
+                return workerAnswer(result.text, details);
+            // Only the model sees the text, never `details`, so the diagnosis
+            // has to be in the text.
+            const text = noAnswer.kind === 'empty-answer' ?
+                describeEmptyAnswer(result)
+                : `Worker failed: ${describeNoAnswer(noAnswer)}`;
+            return workerUnavailable(text, details, noAnswer.kind);
         },
         renderCall(args, theme) {
             const prompt = args.prompt.replace(/\s+/g, ' ').trim();

package/dist/workers/worker-failure.d.ts

@@ -30,9 +30,9 @@ import type { WorkerKillId } from './worker-kill.js';
  * The subset of a finished child result this classification reads.
  *
  * Structural on purpose: `runWorker` returns a superset, and `EnforceChildResult`
- * extends this interface with the one field enforcement adds. Typing the input as
- * what is actually READ lets both pass without either importing the other's
- * interface.
+ * extends this interface with the answer fields enforcement adds. Typing the
+ * input as what is actually READ lets both pass without either importing the
+ * other's interface.
  */
 export interface WorkerFailureInput {
     exitCode: number;
@@ -53,11 +53,11 @@ export interface WorkerFailureInput {
 /**
  * Why the child died, or `undefined` when it finished under its own power.
  *
- * Note what is NOT here: an empty answer, and a reported `modelError` on a run
- * that still produced text. Neither is a kill — whether they count as a failure
- * is the consumer's policy — research-worker.ts, for one, accepts an explicit
- * empty section after a retry — so folding them in would move a decision out of
- * the module that owns it.
+ * Note what is NOT here: a reported `modelError`, a child that never spoke, and
+ * an empty answer. None is a kill — whether they count as a failure is the
+ * consumer's policy — research-worker.ts, for one, accepts an explicit empty
+ * section after a retry. `classifyWorkerAnswer` below names them; each consumer
+ * decides what they mean.
  */
 export type WorkerFailure = {
     kind: 'stalled';
@@ -143,3 +143,32 @@ stderr?: string): string;
  * and that judgement belongs to the caller.
  */
 export declare function classifyWorkerFailure(r: WorkerFailureInput): WorkerFailure | undefined;
+/** The answer-side fields `classifyWorkerAnswer` reads off a finished child. */
+export interface WorkerAnswerInput {
+    text: string;
+    modelError?: string;
+    sawOutput?: boolean;
+    stderr?: string;
+}
+/**
+ * Why a child that was NOT killed still has no answer, or `undefined` for an answer.
+ *
+ * `model-error` wins even next to text. The event sink already drops an error
+ * that a LATER turn answered past, so a `modelError` that survives is one that
+ * came AFTER the last text: the provider died mid-run and the text is partial.
+ * Two consumers once required empty text here and each shipped a truncated
+ * verdict as a whole one.
+ */
+export type WorkerNoAnswer = {
+    kind: 'model-error';
+    cause: string;
+} | {
+    kind: 'dead-child';
+    stderr: string;
+} | {
+    kind: 'empty-answer';
+};
+export declare function classifyWorkerAnswer(r: WorkerAnswerInput): WorkerNoAnswer | undefined;
+/** The one wording of a model error, so a caller can recognise it back (`isModelErrorMessage`). */
+export declare function describeNoAnswer(f: WorkerNoAnswer): string;
+export declare function isModelErrorMessage(msg: string): boolean;

package/dist/workers/worker-failure.js

@@ -138,3 +138,32 @@ export function classifyWorkerFailure(r) {
     }
     return undefined;
 }
+export function classifyWorkerAnswer(r) {
+    if (r.modelError !== undefined && r.modelError.length > 0) {
+        return { kind: 'model-error', cause: r.modelError };
+    }
+    if (r.text.trim().length > 0)
+        return undefined;
+    if (r.sawOutput === false)
+        return { kind: 'dead-child', stderr: r.stderr ?? '' };
+    return { kind: 'empty-answer' };
+}
+const MODEL_ERROR_PREFIX = 'model error — ';
+const CAUSE_MAX = 200;
+const STDERR_TAIL = 300;
+/** The one wording of a model error, so a caller can recognise it back (`isModelErrorMessage`). */
+export function describeNoAnswer(f) {
+    switch (f.kind) {
+        case 'model-error':
+            return `${MODEL_ERROR_PREFIX}${f.cause.slice(0, CAUSE_MAX)}`;
+        case 'dead-child':
+            return ('produced no output — the child never wrote a single byte, so it died '
+                + 'before it could answer'
+                + (f.stderr ? `: ${f.stderr.slice(-STDERR_TAIL)}` : ''));
+        case 'empty-answer':
+            return 'produced no output';
+    }
+}
+export function isModelErrorMessage(msg) {
+    return msg.startsWith(MODEL_ERROR_PREFIX);
+}

package/package.json

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