@mjasnikovs/pi-task 0.40.39 → 0.40.41

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

@@ -318,12 +318,18 @@ export function judgeDeepSession(f) {
         && lastHopJudgesTheClient(r)
         && (r.mimeType ?? '').startsWith('text/html'));
     if (swallowed) {
+        const landed = swallowed.finalPath ?? swallowed.path;
+        const hop = landed === swallowed.path ? '' : ` → \`${landed}\``;
+        const cause = swallowed.redirected ?
+            'The call was bounced to a page, so the session the client carried is not one this '
+                + 'server accepts and the answer is the SPA shell.'
+            : 'The route is not mounted and the catch-all answered instead, so the client sees a '
+                + '200 it cannot parse.';
         return {
             outcome: 'fail',
-            detail: `\`${swallowed.method} ${swallowed.path}\` → ${String(swallowed.status)} `
+            detail: `\`${swallowed.method} ${swallowed.path}\`${hop} → ${String(swallowed.status)} `
                 + `${swallowed.mimeType ?? ''}: an XHR asked this server for data and got the SPA `
-                + 'shell. The route is not mounted and the catch-all answered instead, so the client '
-                + 'sees a 200 it cannot parse. No status check can see this.'
+                + `shell. ${cause} No status check can see this.`
         };
     }
     const { method, path: p, status, failed, redirected: authRedirected } = f.authRequest;
@@ -695,6 +701,7 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
         const existing = requests.get(id);
         if (p.redirectResponse !== undefined && existing) {
             existing.finalUrl = String(req?.url ?? existing.finalUrl);
+            existing.redirected = true;
         }
         else {
             requests.set(id, {
@@ -705,6 +712,7 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
                 status: null,
                 mimeType: null,
                 failed: false,
+                redirected: false,
                 seq: nextSeq++
             });
         }
@@ -779,7 +787,7 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
                 mimeType: r.mimeType,
                 failed: r.failed,
                 initiator: initiatorOf(r),
-                redirected: r.finalUrl !== r.url,
+                redirected: r.redirected,
                 phase: id === authId ? 'auth'
                     : r.seq >= postSeq ? 'post'
                         : 'pre'
@@ -840,12 +848,11 @@ export async function driveSession(cdp, { url, credentials, judge, quietMs }) {
         ?? firstRequest(r => r.seq >= fillSeq && sameOrigin(r) && r.method !== 'GET' && r.type === 'Document');
     // An SSO sign-in addresses this app and ends on the provider, so it is absent
     // from the same-origin log above and "no request to our own origin" would
-    // misname it. Document-only for the same reason the authId fallback is: a
-    // telemetry beacon the fill races that happens to end off-origin would otherwise
-    // name a bogus identity provider.
-    const offsiteSignIn = authId !== null ? null : (firstRequest(r => r.seq >= fillSeq
+    // misname it. The two windows are authId's, for the same reasons: anything the
+    // submit issued counts, and only a NAVIGATION counts back to the fill, where the
+    // background traffic it races would otherwise name a bogus identity provider.
+    const offsiteSignIn = authId !== null ? null : (firstRequest(r => (r.seq >= submitSeq || (r.seq >= fillSeq && r.type === 'Document'))
         && r.method !== 'GET'
-        && r.type === 'Document'
         && addressedOrigin(r)
         && !sameOrigin(r)
         && r.finalUrl.startsWith('http')));

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