@mjasnikovs/pi-task 0.40.40 → 0.40.41

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

@@ -96,6 +96,7 @@ export declare function parseEnforceVerdict(text: string): {
 /** The subset of a runWorker result the enforcement-child mapping reads. */
 export interface EnforceChildResult extends WorkerFailureInput {
     text: string;
+    modelError?: string;
 }
 /**
  * Map the enforcement child's runWorker result to a fatal error message, or null

package/dist/task/enforce-guidelines.js

@@ -236,9 +236,19 @@ export function parseEnforceVerdict(text) {
  * effects don't get re-classified as a user cancel or a crash.
  */
 export function classifyEnforceChildFailure(r) {
-    const failure = classifyWorkerFailure(r);
-    if (!failure)
-        return null;
+    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;
+}
+function describeKill(failure) {
     switch (failure.kind) {
         case 'stalled':
             // Otherwise a long silence is reported as a user cancel.

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

@@ -19,10 +19,28 @@ import { runWorker } from './pi-worker-core.js';
 import { contextWindowForGroup } from '../task/context-usage.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 => x.reason),
+        ...(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 +85,25 @@ 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);
+            // 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);
         },
         renderCall(args, theme) {
             const prompt = args.prompt.replace(/\s+/g, ' ').trim();

package/package.json

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