@mjasnikovs/pi-task 0.13.24 → 0.13.26

package/README.md

@@ -1,8 +1,8 @@
 <div align="center">
 
-<img src="https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.svg" alt="pi-task pipeline: a /task request runs through refine, research, grill, compose and critique, then the final spec is delivered to your main pi session in the same chat. Every phase boundary is persisted to .pi-tasks/TASK_NNNN.md, so the task is crash-safe and resumable." width="820"/>
+![pi-task pipeline: a /task request runs through refine, research, grill, compose and critique, then the final spec is delivered to your main pi session in the same chat. Every phase boundary is persisted to .pi-tasks/TASK_NNNN.md, so the task is crash-safe and resumable.](https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.svg)
 
-# <img src="https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pi-logo.svg" alt="" height="30" align="top"/> pi-task
+# pi-task
 
 **Deterministic spec-orchestration for local models — with bundled web, docs, fetch, and worker sub-agent tools.**
 
@@ -69,7 +69,7 @@ A real feature is usually several tasks, not one. `/task-auto` is a thin planner
 
 <div align="center">
 
-<img src="https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/task-auto.svg" alt="/task-auto plans a feature: it clarifies the gray areas, decomposes the answers into an ordered list of task titles written to TASK_AUTO_NNNN.md, then runs each unchecked title through the full /task pipeline one at a time, ticking the box before moving on." width="820"/>
+![/task-auto plans a feature: it clarifies the gray areas, decomposes the answers into an ordered list of task titles written to TASK_AUTO_NNNN.md, then runs each unchecked title through the full /task pipeline one at a time, ticking the box before moving on.](https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/task-auto.svg)
 
 </div>
 

package/dist/task/phases.d.ts

@@ -56,6 +56,14 @@ export interface PhaseResearchDeps extends ExternalContextDeps {
  * mentions; the rest are unchanged or only lightly trimmed.
  */
 export declare function scopedToolingGoal(refined: string): string;
+/**
+ * Build a degraded section body for a runaway worker: a one-line marker naming
+ * the failure (so downstream phases and a human reading the task file know this
+ * section is incomplete) followed by whatever partial answer the worker streamed
+ * before it was killed. The marker is always present even when there is no
+ * partial text, so an empty degrade is never mistaken for a real finding.
+ */
+export declare function degradedSectionBody(name: string, reason: string, partial: string): string;
 export declare function phaseResearch(deps: PhaseDeps, refined: string, researchDeps?: PhaseResearchDeps): Promise<string>;
 export interface PhaseAutoAnswerDeps {
     docsFocused?: typeof docsFocused;

package/dist/task/phases.js

@@ -122,34 +122,67 @@ export function scopedToolingGoal(refined) {
     return firstBullet === -1 ? goal : goal.slice(0, firstBullet).trim();
 }
 /**
- * Throw a descriptive error if a research worker's result is not trustworthy
- * output, so only good output is ever cached and assembled. Precedence mirrors
- * the original inline checks: loop/timeout exhaustion first (a loop-kill is a
- * SIGTERM/exit 143 OR a clean exit 0 with partial text, so exitCode alone is
- * ambiguous — the worker already burned its MAX_LOOP_RESTARTS restarts before
- * setting these), then exit code, empty output, and finally a leaked
- * (never-executed) tool call.
+ * Classify a research worker's result so the phase can react per-worker instead
+ * of treating every failure the same. Two distinct failure shapes:
+ *
+ *   - 'runaway' (loop-kill OR per-worker wall-clock timeout): the worker explored
+ *     too long and was killed *after* burning its MAX_LOOP_RESTARTS restarts. It
+ *     did real work and left partial text; the other three workers are unaffected.
+ *     Failing the whole task here would throw away every already-good worker AND
+ *     abort the entire auto-run over the weakest section — and because the loop is
+ *     deterministic, a resume just re-loops and re-fails. So this DEGRADES: keep
+ *     the partial answer (marked), cache it, move on. A loop-kill is a SIGTERM
+ *     (exit 143) OR a clean exit 0 with truncated text, so loopHit/timedOut — not
+ *     exitCode — are the reliable signal and are checked first.
+ *
+ *   - 'fatal' (non-zero exit that isn't a loop-kill, empty output, or a leaked
+ *     never-executed tool call): the output is untrustworthy in a way partial text
+ *     can't paper over (broken env, model disconnect, wrong tool-call dialect).
+ *     These still throw — degrading them would launder a real breakage into a
+ *     plausible-looking section. Returns null when the result is trustworthy.
  */
-function assertResearchWorkerOk(name, result) {
+function classifyResearchWorker(name, result) {
     if (result.loopHit) {
         const argsStr = JSON.stringify(result.loopHit.call.args);
-        throw new Error(`Research ${name} worker stuck in a loop — called `
-            + `${result.loopHit.call.name}(${argsStr}) ×${result.loopHit.count} in the last `
-            + `${result.loopHit.windowSize} calls and still looped after restarts`);
+        return {
+            kind: 'runaway',
+            reason: `stuck in a loop — called ${result.loopHit.call.name}(${argsStr}) `
+                + `×${result.loopHit.count} in the last ${result.loopHit.windowSize} calls `
+                + `and still looped after restarts`
+        };
     }
     if (result.timedOut) {
-        throw new Error(`Research ${name} worker timed out after restarts`);
+        return { kind: 'runaway', reason: 'timed out after restarts' };
     }
     if (result.exitCode !== 0) {
-        throw new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`);
+        return {
+            kind: 'fatal',
+            error: new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`)
+        };
     }
     if (result.text.trim().length === 0) {
-        throw new Error(`Research ${name} worker produced no output`);
+        return { kind: 'fatal', error: new Error(`Research ${name} worker produced no output`) };
     }
     if (result.leakedToolCall) {
-        throw new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
-            + `(${result.leakedToolCall.trim()}) — it never ran`);
+        return {
+            kind: 'fatal',
+            error: new Error(`Research ${name} worker wrote a tool call as text instead of invoking it `
+                + `(${result.leakedToolCall.trim()}) — it never ran`)
+        };
     }
+    return null;
+}
+/**
+ * Build a degraded section body for a runaway worker: a one-line marker naming
+ * the failure (so downstream phases and a human reading the task file know this
+ * section is incomplete) followed by whatever partial answer the worker streamed
+ * before it was killed. The marker is always present even when there is no
+ * partial text, so an empty degrade is never mistaken for a real finding.
+ */
+export function degradedSectionBody(name, reason, partial) {
+    const marker = `(degraded: research ${name} worker ${reason}; this section may be incomplete)`;
+    const body = partial.trim();
+    return body.length > 0 ? `${marker}\n\n${body}` : marker;
 }
 export async function phaseResearch(deps, refined, researchDeps = {}) {
     const fileInventoryFn = researchDeps.getFileInventory ?? getFileInventory;
@@ -265,11 +298,21 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             + (r.stderr ? ` stderr=${r.stderr.slice(0, 300)}` : '')
             + (r.leakedToolCall ? ` leaked=${r.leakedToolCall.trim().slice(0, 80)}` : ''));
         updateProgress();
-        // Throws (failing the phase) on a loop/timeout/exit/empty/leak — so the
-        // workers that already succeeded above stay cached for the resume.
-        assertResearchWorkerOk(spec.section, r);
-        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, r.text);
-        sections.push({ name: spec.section, text: r.text.trim() });
+        // A fatal failure (crash/empty/leak) still throws — the already-cached
+        // workers survive for the resume. A runaway (loop/timeout) degrades to its
+        // partial output instead, so one weak worker can't abort a whole auto-run;
+        // the degraded section is cached too, so a resume doesn't re-loop it.
+        const failure = classifyResearchWorker(spec.section, r);
+        if (failure?.kind === 'fatal')
+            throw failure.error;
+        const sectionText = failure?.kind === 'runaway' ?
+            degradedSectionBody(spec.section, failure.reason, r.text)
+            : r.text.trim();
+        if (failure?.kind === 'runaway') {
+            deps.logDebug?.(`${spec.label}: degraded — ${failure.reason}`);
+        }
+        await setTaskSection(deps.cwd, deps.taskId, cacheHeading, sectionText);
+        sections.push({ name: spec.section, text: sectionText });
     }
     // All workers succeeded — the assembled output below becomes the canonical
     // 'research' section (written by the orchestrator). The per-worker caches

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.13.24",
+    "version": "0.13.26",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",
@@ -66,6 +66,7 @@
     "pi": {
         "extensions": [
             "dist/index.js"
-        ]
+        ],
+        "image": "https://raw.githubusercontent.com/mjasnikovs/pi-task/main/assets/pipeline.png"
     }
 }