@mjasnikovs/pi-task 0.40.41 → 0.40.43

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

@@ -37,9 +37,37 @@ export type SpawnFn = (command: string, args: ReadonlyArray<string>, options: {
      *  possible at all: with `detached`, a `kill(-pid)` issued after the child
      *  has exited still takes the backgrounded grandchild with it; without it
      *  the same call throws ESRCH and the grandchild survives. Set only for
-     *  model children (json-events); plumbing stays in-group. */
+     *  model children (json-events); plumbing stays in-group. Never set on
+     *  win32 — see ownGroupSpawnOptions. */
     detached?: boolean;
+    /** win32 only: keep the child's console off-screen. */
+    windowsHide?: boolean;
 }) => ProcLike;
+/**
+ * Spawn options that make a model child reapable with everything it backgrounds.
+ *
+ * POSIX (linux, darwin): `detached` = own process group, so `kill(-pid)` sweeps
+ * the grandchildren. On win32 the same flag is a defect: libuv maps it to
+ * DETACHED_PROCESS, which gives the child NO console, so every console process
+ * the model then runs allocates a fresh visible one (issue #20). win32 gets
+ * `windowsHide` (CREATE_NO_WINDOW) instead: the child gets a windowless console
+ * that its descendants inherit. Either/or is load-bearing — Windows ignores
+ * CREATE_NO_WINDOW next to DETACHED_PROCESS. The win32 reap is `taskkill /T`,
+ * which walks the live tree and needs no flag; unlike a POSIX group kill it
+ * cannot catch what the child left behind after it exited.
+ */
+export declare function ownGroupSpawnOptions(platform: NodeJS.Platform): OwnGroupSpawnOptions;
+export type OwnGroupSpawnOptions = {
+    detached: true;
+} | {
+    windowsHide: true;
+};
+/**
+ * Tear down a child spawned with `ownGroupSpawnOptions`, and whatever it
+ * backgrounded. Best-effort: a group already gone is not an error. Kept beside
+ * the spawn shape so a platform change edits one file.
+ */
+export declare function reapProcessGroup(pid: number, sig: NodeJS.Signals, 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
@@ -124,6 +152,9 @@ export interface RunChildTextOptions {
 }
 export interface RunChildJsonEventsOptions {
     mode: 'json-events';
+    /** Which platform's group options and reap to use. Tests drive the win32 arm
+     *  from a POSIX host with it; production leaves it to `process.platform`. */
+    platform?: NodeJS.Platform;
     onLine?: (line: string) => void;
     onContextUsage?: (snapshot: ContextSnapshot) => void;
     /**

package/dist/shared/child-process.js

@@ -13,6 +13,40 @@ export const CHILD_BASE_ARGS = [
     '--no-context-files',
     '--no-session'
 ];
+/**
+ * Spawn options that make a model child reapable with everything it backgrounds.
+ *
+ * POSIX (linux, darwin): `detached` = own process group, so `kill(-pid)` sweeps
+ * the grandchildren. On win32 the same flag is a defect: libuv maps it to
+ * DETACHED_PROCESS, which gives the child NO console, so every console process
+ * the model then runs allocates a fresh visible one (issue #20). win32 gets
+ * `windowsHide` (CREATE_NO_WINDOW) instead: the child gets a windowless console
+ * that its descendants inherit. Either/or is load-bearing — Windows ignores
+ * CREATE_NO_WINDOW next to DETACHED_PROCESS. The win32 reap is `taskkill /T`,
+ * which walks the live tree and needs no flag; unlike a POSIX group kill it
+ * cannot catch what the child left behind after it exited.
+ */
+export function ownGroupSpawnOptions(platform) {
+    return platform === 'win32' ? { windowsHide: true } : { detached: true };
+}
+/**
+ * Tear down a child spawned with `ownGroupSpawnOptions`, and whatever it
+ * backgrounded. Best-effort: a group already gone is not an error. Kept beside
+ * the spawn shape so a platform change edits one file.
+ */
+export function reapProcessGroup(pid, sig, platform = process.platform) {
+    try {
+        if (platform === 'win32') {
+            spawnSyncDefault('taskkill', ['/pid', String(pid), '/T', '/F']);
+        }
+        else {
+            process.kill(-pid, sig);
+        }
+    }
+    catch {
+        // group already gone
+    }
+}
 /** The cause a signal was aborted with, when its owner attached one. */
 function abortCause(reason) {
     const tagged = reason;
@@ -229,11 +263,12 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
         // OWN process group so every such grandchild can be reaped as a unit on exit.
         // Plumbing (git, mode:'text') never backgrounds anything and stays in-group.
         const ownGroup = opts?.mode === 'json-events';
+        const platform = (ownGroup && opts.platform) || process.platform;
         const proc = spawn(invocation.command, invocation.args, {
             cwd,
             shell: false,
             stdio: [usesStdin ? 'pipe' : 'ignore', 'pipe', 'pipe'],
-            ...(ownGroup ? { detached: true } : {}),
+            ...(ownGroup ? ownGroupSpawnOptions(platform) : {}),
             ...(invocation.env ? { env: invocation.env } : {})
         });
         if (usesStdin) {
@@ -250,23 +285,11 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             proc.stdin?.end();
         }
         // Reap the child's whole process group — the child itself AND anything it
-        // backgrounded. No-op unless the child owns a group (ownGroup) and we have a
-        // pid; ESRCH (group already gone) is swallowed. POSIX: negative-pid signals
-        // the group; Windows has no groups, so taskkill /T tears down the tree.
+        // backgrounded. No-op unless the child owns a group (ownGroup) and we have a pid.
         const reapGroup = (sig) => {
             if (!ownGroup || !proc.pid)
                 return;
-            try {
-                if (process.platform === 'win32') {
-                    spawnSyncDefault('taskkill', ['/pid', String(proc.pid), '/T', '/F']);
-                }
-                else {
-                    process.kill(-proc.pid, sig);
-                }
-            }
-            catch {
-                // group already gone
-            }
+            reapProcessGroup(proc.pid, sig, platform);
         };
         // One kill path for every source: SIGTERM, then SIGKILL after a grace
         // period if the child ignored the term. For a group-owning (model) child,

package/dist/task/boot-probe.d.ts

@@ -1,4 +1,5 @@
 import type { RenderOutcome } from './render-check.js';
+import type { OwnGroupSpawnOptions } from '../shared/child-process.js';
 import { type DeepRenderOutcome } from './deep-render-check.js';
 import type { HealthCommand } from './repo-health-check.js';
 /**
@@ -163,14 +164,16 @@ export interface BootDeps {
      * fake pid would signal something else entirely.
      */
     killGroup?: (pid: number, signal: NodeJS.Signals) => void;
+    /** Which platform's group options to spawn with. Tests drive the win32 arm
+     *  from a POSIX host; production leaves it to `process.platform`. */
+    platform?: NodeJS.Platform;
 }
 /** What `runBootCheck` passes to its spawn. */
-export interface BootSpawnOptions {
+export type BootSpawnOptions = {
     cwd: string;
-    detached: true;
     stdio: ['ignore', 'pipe', 'pipe'];
     env: Record<string, string | undefined>;
-}
+} & OwnGroupSpawnOptions;
 /** A stream the boot check reads output from. */
 export interface BootStream {
     on: (event: 'data', cb: (chunk: Buffer | string) => void) => void;
@@ -255,8 +258,9 @@ export declare function defaultFindPortHolder(port: number): {
  *
  *   - non-zero exit (or signal death) before the window closes → FAIL, output tail;
  *   - exit 0 before the window closes → PASS (a CLI-style "run" that finished);
- *   - still alive when the window closes → PASS, then the whole process group is
- *     killed (detached spawn = own group; SIGTERM, escalating to SIGKILL).
+ *   - still alive when the window closes → PASS, then the child and everything it
+ *     backgrounded are killed (ownGroupSpawnOptions + reapProcessGroup; SIGTERM,
+ *     escalating to SIGKILL).
  *
  * For a SERVED app (`expectServer` true — the spec/plan promised an HTTP server) mere
  * survival is not enough: a watcher (`dev` = tailwind/bundler --watch) stays alive

package/dist/task/boot-probe.js

@@ -25,6 +25,7 @@ import * as path from 'node:path';
 import { runRenderCheck } from './render-check.js';
 import { resolveRunner, runnerEnv, isCommandNotFound } from './runner-resolve.js';
 import { outputTail } from './command-run.js';
+import { ownGroupSpawnOptions, reapProcessGroup } from '../shared/child-process.js';
 import { packageScripts, makeHasTarget } from './launch-manifest.js';
 import { collectProjectEnv, pinnedLocalPort, runDeepRenderCheck } from './deep-render-check.js';
 /** Leading `FOO=bar` env assignments and `sudo`/`exec` wrappers carry no verb. */
@@ -435,7 +436,8 @@ function pgidOf(pid) {
     }
 }
 /** Default listener probe: any LISTENing socket owned by a pid in process group
- *  `pgid` (the detached boot child IS its own group leader, so pgid === child.pid). */
+ *  `pgid`. POSIX only (expectServer is fenced off win32): there the detached boot
+ *  child leads its own group, so pgid === child.pid. */
 function defaultGroupHasListener(pgid) {
     for (const { pid } of listeningSockets()) {
         if (pgidOf(pid) === pgid)
@@ -503,26 +505,9 @@ function holderIsOurs(command, boot) {
 function defaultSpawnBoot(bin, args, o) {
     return spawn(bin, args, o);
 }
-/**
- * The real group teardown, best-effort. A group already gone is not an error.
- *
- * On POSIX the negative pid signals the whole group, which is what makes a
- * `detached` spawn reapable together with anything it backgrounded. Windows has
- * neither process groups nor a negative-pid kill, so that branch shells out to
- * `taskkill /T /F` as a single forced tree teardown instead of escalating.
- */
+/** The real group teardown; the spawn shape's twin lives beside it. */
 function defaultKillGroup(pid, sig) {
-    try {
-        if (process.platform === 'win32') {
-            spawnSync('taskkill', ['/pid', String(pid), '/T', '/F']);
-        }
-        else {
-            process.kill(-pid, sig);
-        }
-    }
-    catch {
-        // group already gone
-    }
+    reapProcessGroup(pid, sig);
 }
 /**
  * Exercise the start command ONCE. All four outcomes below were run against real
@@ -533,8 +518,9 @@ function defaultKillGroup(pid, sig) {
  *
  *   - non-zero exit (or signal death) before the window closes → FAIL, output tail;
  *   - exit 0 before the window closes → PASS (a CLI-style "run" that finished);
- *   - still alive when the window closes → PASS, then the whole process group is
- *     killed (detached spawn = own group; SIGTERM, escalating to SIGKILL).
+ *   - still alive when the window closes → PASS, then the child and everything it
+ *     backgrounded are killed (ownGroupSpawnOptions + reapProcessGroup; SIGTERM,
+ *     escalating to SIGKILL).
  *
  * For a SERVED app (`expectServer` true — the spec/plan promised an HTTP server) mere
  * survival is not enough: a watcher (`dev` = tailwind/bundler --watch) stays alive
@@ -593,7 +579,7 @@ export async function runBootCheck(cwd, [bin, args], graceMs = 10_000, opts = {}
     return new Promise(resolve => {
         const child = spawnBoot(runner.bin, args, {
             cwd,
-            detached: true,
+            ...ownGroupSpawnOptions(opts.deps?.platform ?? process.platform),
             stdio: ['ignore', 'pipe', 'pipe'],
             env: {
                 ...runnerEnv(runner),

package/dist/task/deep-render-check.js

@@ -44,6 +44,7 @@ import * as os from 'node:os';
 import * as path from 'node:path';
 import WebSocket from 'ws';
 import { findHeadlessBrowser, judgeRenderedDom } from './render-check.js';
+import { ownGroupSpawnOptions, reapProcessGroup } from '../shared/child-process.js';
 /** Identifier halves of a credential pair, in preference order. */
 const IDENTIFIER_SUFFIXES = ['PHONE', 'EMAIL', 'USERNAME', 'USER', 'LOGIN', 'IDENTIFIER'];
 const PASSWORD_SUFFIXES = ['PASSWORD', 'PASSWD', 'PASS'];
@@ -622,13 +623,8 @@ export async function launchBrowser(bin, userDataDir, { signal } = {}) {
         catch {
             // socket already gone
         }
-        try {
-            if (child?.pid)
-                process.kill(-child.pid, 'SIGKILL');
-        }
-        catch {
-            // group already gone
-        }
+        if (child?.pid)
+            reapProcessGroup(child.pid, 'SIGKILL');
         return Promise.resolve();
     };
     signal?.addEventListener('abort', () => void close(), { once: true });
@@ -647,7 +643,7 @@ export async function launchBrowser(bin, userDataDir, { signal } = {}) {
             `--user-data-dir=${userDataDir}`,
             '--remote-debugging-port=0',
             'about:blank'
-        ], { detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+        ], { ...ownGroupSpawnOptions(process.platform), stdio: ['ignore', 'pipe', 'pipe'] });
         const proc = child;
         proc.unref();
         const wsUrl = await new Promise((resolve, reject) => {

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,9 +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;
-    modelError?: string;
+export interface EnforceChildResult extends WorkerFailureInput, WorkerAnswerInput {
 }
 /**
  * Map the enforcement child's runWorker result to a fatal error message, or null
@@ -115,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,24 +229,26 @@ 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 kill = classifyWorkerFailure(r);
     const named = kill ? describeKill(kill) : null;
     if (named !== null)
         return named;
-    // Not a kill, so the ladder leaves it to the consumer: pi reports a failed
-    // turn as exit 0, empty text, and the cause in `modelError`. Unread, the
-    // empty text parses as "no verdict" and a dead provider is blamed on the work.
-    // Checked after a surviving loop too — that arm is a warning, not an answer.
-    return r.modelError && r.text.trim().length === 0 ?
-        `model error — ${r.modelError.slice(0, 200)}`
-        : null;
+    const noAnswer = classifyWorkerAnswer(r);
+    if (!noAnswer || noAnswer.kind === 'empty-answer')
+        return null;
+    return describeNoAnswer(noAnswer);
 }
 function describeKill(failure) {
     switch (failure.kind) {

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.js

@@ -17,6 +17,7 @@ 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;
@@ -24,7 +25,10 @@ function workerDetails(r) {
     return {
         exitCode: r.exitCode,
         attempts: r.attempts,
-        restarts: r.restarts.map(x => x.reason),
+        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) } : {})
     };
@@ -94,16 +98,15 @@ export function registerPiWorker(pi, internals = {}) {
             if (failure !== null) {
                 return workerUnavailable(failure, details, childFailureReason(result));
             }
-            // Not a kill, so the ladder leaves it to us: pi reports a failed turn
-            // as exit 0, empty text, and the cause in `modelError`.
-            if (result.modelError && result.text.trim().length === 0) {
-                return workerUnavailable(`Worker failed: model error — ${result.modelError.slice(0, 200)}`, details, 'model-error');
-            }
-            const text = result.text.trim();
-            if (text.length === 0) {
-                return workerUnavailable(describeEmptyAnswer(result), details, 'no-answer');
-            }
-            return workerAnswer(result.text, 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.41",
+    "version": "0.40.43",
     "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",