@mjasnikovs/pi-task 0.13.15 → 0.13.16

package/dist/task/auto-orchestrator.js

@@ -304,7 +304,11 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             }
             if (!res.ok) {
                 await updateTaskFrontMatter(cwd, id, { state: 'failed' });
-                announceDone(active, `${id} stopped at "${next.title}" — fix and run /task-auto-resume.`, 'error');
+                // res.reason is set when the implementation turn itself died
+                // (e.g. a context-overflow 400) — surface it so the real cause
+                // isn't lost behind the generic "stopped" message.
+                const why = res.reason ? ` — ${res.reason.slice(0, 160)}` : '';
+                announceDone(active, `${id} stopped at "${next.title}"${why} — fix and run /task-auto-resume.`, 'error');
                 return;
             }
             // res.ok === true means runner.run() completed, so res.taskId is the

package/dist/task/orchestrator.d.ts

@@ -108,6 +108,14 @@ export interface RunSingleTaskResult {
      * uninterrupted.
      */
     interrupted?: boolean;
+    /**
+     * Why the run is not ok, when known. Set when a waitForImplementation turn
+     * ended with stopReason "error" (the model/provider died mid-implementation —
+     * e.g. a context-overflow 400 — after the task file was already marked
+     * `completed` at spec-handoff). The /task-auto loop surfaces this in its
+     * "stopped at …" message so the real cause isn't lost. Undefined otherwise.
+     */
+    reason?: string;
 }
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and

package/dist/task/orchestrator.js

@@ -288,6 +288,29 @@ function wasInterrupted(ctx) {
     }
     return false;
 }
+/**
+ * The error cause when the most recent assistant turn ended with stopReason
+ * "error" — the model/provider failed mid-implementation (context overflow,
+ * disconnect, provider 5xx) after pi exhausted its own retries. Returns the
+ * provider's errorMessage, or undefined if the turn ended cleanly ("stop") or
+ * was user-aborted ("aborted", handled by wasInterrupted).
+ *
+ * The /task-auto loop reads this AFTER the implementation wait: a task's file is
+ * marked `completed` at spec-handoff (before implementation), so without this
+ * check an implementation turn that died — e.g. "400 ... exceeds the available
+ * context size" — would still read as ok and get checked off and committed.
+ */
+function implementationError(ctx) {
+    const entries = ctx.sessionManager.getEntries();
+    for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i];
+        if ('message' in e && 'role' in e.message && e.message.role === 'assistant') {
+            const m = e.message;
+            return m.stopReason === 'error' ? (m.errorMessage ?? 'model error') : undefined;
+        }
+    }
+    return undefined;
+}
 /**
  * After the implementation turn settles, honour a user ESC by letting them steer.
  *
@@ -326,6 +349,11 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     // cancellation path (where no replacement occurs).
     let freshCtx = ctx;
     let interrupted = false;
+    // The implementation turn's failure cause, when it ended with stopReason
+    // "error" (only meaningful in the waitForImplementation path). The task file
+    // was already marked `completed` at spec-handoff, so this is the only signal
+    // that the implementation itself died and the task must not be checked off.
+    let implError;
     const result = await ctx.newSession({
         withSession: async (newCtx) => {
             freshCtx = newCtx;
@@ -335,6 +363,10 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                 if (opts.waitForImplementation) {
                     await newCtx.waitForIdle();
                     interrupted = await steerUntilDone(newCtx, opts.promptSteer);
+                    // A user-declined steer (interrupted) is its own paused
+                    // path; otherwise inspect how the turn actually ended.
+                    if (!interrupted)
+                        implError = implementationError(newCtx);
                 }
             }, opts.spawnFn, opts.onStart);
             await runner.run();
@@ -360,13 +392,18 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
             ok = false;
         }
     }
+    // The file reads `completed` from spec-handoff even when the implementation
+    // turn then died. Demote to a failure so /task-auto stops here (leaving the
+    // entry unchecked and resumable) instead of committing and advancing.
+    if (ok && implError)
+        ok = false;
     if (opts.notifyFinish) {
         // One push per top-level /task or /task-resume, on any terminal end. The
         // file state is the source of truth: 'completed' on success, 'failed' /
         // 'cancelled' otherwise; an unreadable/absent file falls back to 'ended'.
         void pushNotify('Task finished', `${taskId || 'Task'} ${state ?? 'ended'}.`, 'pi-end').catch(() => { });
     }
-    return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted };
+    return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted, reason: implError };
 }
 // ─── Command handlers ────────────────────────────────────────────────────────
 async function handleTask(args, ctx) {

package/package.json

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