@mjasnikovs/pi-task 0.13.10 → 0.13.12

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

@@ -21,6 +21,14 @@ export interface ChildResult {
     aborted: boolean;
     /** Extracted assistant text (only populated in json-events mode). */
     text?: string;
+    /**
+     * The model-failure cause, when the child's final turn carried
+     * stopReason "error" (provider/connection failure after pi exhausted its
+     * own retries). pi emits this as an agent_end whose assistant message has
+     * empty text, so without it the phase would mis-report "produced no output".
+     * Only populated in json-events mode.
+     */
+    modelError?: string;
 }
 export interface ToolCall {
     name: string;
@@ -74,6 +82,13 @@ export declare class JsonEventSink {
     private readonly onLoopKill;
     /** Final assistant text from the agent_end event, if one arrived. */
     finalText: string;
+    /**
+     * Set when the final assistant turn carried stopReason "error" — i.e. the
+     * model/provider failed (disconnect, fetch failed, socket hang up, 5xx)
+     * after pi exhausted its internal retries. Holds the provider's errorMessage
+     * so callers can report the real cause instead of an empty completion.
+     */
+    modelError: string | undefined;
     private textDeltaAccum;
     private buf;
     constructor(opts: RunChildJsonEventsOptions, 

package/dist/shared/child-process.js

@@ -24,6 +24,13 @@ export class JsonEventSink {
     onLoopKill;
     /** Final assistant text from the agent_end event, if one arrived. */
     finalText = '';
+    /**
+     * Set when the final assistant turn carried stopReason "error" — i.e. the
+     * model/provider failed (disconnect, fetch failed, socket hang up, 5xx)
+     * after pi exhausted its internal retries. Holds the provider's errorMessage
+     * so callers can report the real cause instead of an empty completion.
+     */
+    modelError = undefined;
     textDeltaAccum = '';
     // json-events lines can split across data chunks; this holds the trailing
     // partial line between feeds so events spanning a boundary still parse. We
@@ -97,7 +104,20 @@ export class JsonEventSink {
         if (t === 'agent_end' && Array.isArray(evt.messages)) {
             for (let i = evt.messages.length - 1; i >= 0; i--) {
                 const m = evt.messages[i];
-                if (m && m.role === 'assistant' && Array.isArray(m.content)) {
+                if (!m || m.role !== 'assistant')
+                    continue;
+                // A model failure (disconnect, fetch failed, socket hang up, 5xx
+                // after pi's own retries) arrives as an assistant message with
+                // stopReason "error" and the real cause in errorMessage — but
+                // EMPTY text content. Capture it so the phase reports the actual
+                // failure instead of the useless "produced no output".
+                if (m.stopReason === 'error'
+                    && typeof m.errorMessage === 'string'
+                    && m.errorMessage.length > 0
+                    && this.modelError === undefined) {
+                    this.modelError = m.errorMessage;
+                }
+                if (Array.isArray(m.content)) {
                     const texts = [];
                     for (const c of m.content) {
                         if (c?.type === 'text' && typeof c.text === 'string') {
@@ -186,7 +206,14 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             if (sink)
                 sink.flush();
             const text = sink ? sink.text : undefined;
-            resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
+            resolve({
+                stdout,
+                stderr,
+                exitCode: code ?? 0,
+                aborted,
+                text,
+                modelError: sink?.modelError
+            });
         });
         proc.on('error', () => {
             resolve({ stdout, stderr, exitCode: 1, aborted });

package/dist/task/auto-orchestrator.js

@@ -280,6 +280,16 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 active.ui.notify(`${id} paused — could not start a session. Run /task-auto-resume to retry.`, 'warning');
                 return;
             }
+            if (res.interrupted) {
+                // The user interrupted implementation (ESC) and then declined to
+                // steer (empty steer prompt) — they want to stop here. Pause
+                // without checking the task off, so /task-auto-resume re-delivers
+                // this task's spec to finish it. (A plain ESC that the user
+                // follows with steering text never reaches here — that loops on
+                // the same task inside runSingleTask until a turn completes.)
+                active.ui.notify(`${id} paused at "${next.title}" — resume with /task-auto-resume.`, 'warning');
+                return;
+            }
             if (!res.ok) {
                 await updateTaskFrontMatter(cwd, id, { state: 'failed' });
                 active.ui.notify(`${id} stopped at "${next.title}" — fix and run /task-auto-resume.`, 'error');

package/dist/task/child-runner.d.ts

@@ -16,6 +16,8 @@ export interface PhaseRunResult {
     loopHit?: LoopHit;
     /** Set when the assistant text contains an unexecuted, leaked tool call. */
     leakedToolCall?: string;
+    /** Set when the child's final turn failed with stopReason "error" (model/provider failure). */
+    modelError?: string;
 }
 export declare function childArgs(tools: string, prompt: string): string[];
 export declare const USER_CANCELLED = "__user_cancelled__";
@@ -74,6 +76,22 @@ export declare class LoopExhaustedError extends Error {
     readonly history: LoopHit[];
     constructor(phase: string, history: LoopHit[]);
 }
+/**
+ * Thrown when a phase child's final turn failed with stopReason "error" — the
+ * model/provider died (local model disconnect, fetch failed, socket hang up,
+ * provider 5xx) after pi exhausted its own internal retries. pi reports this as
+ * an agent_end with empty assistant text, which would otherwise surface as the
+ * misleading "produced no output"; this names the real cause instead.
+ *
+ * Fail-fast: not retried at the pi-task layer. pi already retried the retryable
+ * cases; re-spawning a fresh child against the same dead endpoint only burns
+ * time and buries the real error. Restart the model/provider, then resume.
+ */
+export declare class ModelError extends Error {
+    readonly phase: string;
+    readonly cause: string;
+    constructor(phase: string, cause: string);
+}
 /**
  * Thrown when a phase child repeatedly wrote a tool call as plain text (a markup
  * dialect pi's harness didn't parse) instead of invoking it. The call never ran,

package/dist/task/child-runner.js

@@ -69,6 +69,7 @@ export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsag
         exitCode: result.exitCode,
         stderr: result.stderr.trim(),
         loopHit,
+        modelError: result.modelError,
         // A tool call the model wrote as text (wrong dialect) never executed and
         // sailed past the structured-event guards above; flag it so the wrappers
         // can re-prompt instead of accepting the unexecuted call. Only meaningful
@@ -90,6 +91,11 @@ export async function runPhaseChild(deps, name, tools, prompt) {
         if (r.exitCode !== 0) {
             throw new Error(`${name} child failed: ${r.stderr || '(no stderr)'}`);
         }
+        if (r.modelError) {
+            // The model/provider failed (pi exited 0 with an stopReason "error"
+            // turn). Surface the real cause and fail fast — pi already retried.
+            throw new ModelError(name, r.modelError);
+        }
         if (r.text.trim().length === 0) {
             // An empty completion (exit 0, no assistant text, no stderr) is almost
             // always transient — a model/API error swallowed inside --mode json,
@@ -161,6 +167,11 @@ export async function runPhaseWithLoopGuard(deps, name, tools, buildPrompt) {
         if (r.exitCode !== 0) {
             throw new Error(`${name} child failed: ${r.stderr || '(no stderr)'}`);
         }
+        if (r.modelError) {
+            // The model/provider failed (pi exited 0 with a stopReason "error"
+            // turn). Surface the real cause and fail fast — pi already retried.
+            throw new ModelError(name, r.modelError);
+        }
         if (r.text.trim().length === 0) {
             // An empty completion (exit 0, no assistant text, no stderr) is almost
             // always transient — a model/API error swallowed inside --mode json,
@@ -210,6 +221,28 @@ export class LoopExhaustedError extends Error {
         this.name = 'LoopExhaustedError';
     }
 }
+// ─── ModelError ──────────────────────────────────────────────────────────────
+/**
+ * Thrown when a phase child's final turn failed with stopReason "error" — the
+ * model/provider died (local model disconnect, fetch failed, socket hang up,
+ * provider 5xx) after pi exhausted its own internal retries. pi reports this as
+ * an agent_end with empty assistant text, which would otherwise surface as the
+ * misleading "produced no output"; this names the real cause instead.
+ *
+ * Fail-fast: not retried at the pi-task layer. pi already retried the retryable
+ * cases; re-spawning a fresh child against the same dead endpoint only burns
+ * time and buries the real error. Restart the model/provider, then resume.
+ */
+export class ModelError extends Error {
+    phase;
+    cause;
+    constructor(phase, cause) {
+        super(`${phase} child: model error — ${cause}`);
+        this.phase = phase;
+        this.cause = cause;
+        this.name = 'ModelError';
+    }
+}
 // ─── LeakedToolCallError ─────────────────────────────────────────────────────
 /**
  * Thrown when a phase child repeatedly wrote a tool call as plain text (a markup

package/dist/task/failure-classifier.js

@@ -4,7 +4,7 @@
  */
 import { updateTaskFrontMatter } from './task-io.js';
 import { flashTerminalWidget } from './widget.js';
-import { LoopExhaustedError, LeakedToolCallError, USER_CANCELLED } from './child-runner.js';
+import { LoopExhaustedError, LeakedToolCallError, ModelError, USER_CANCELLED } from './child-runner.js';
 // ─── Classifier ──────────────────────────────────────────────────────────────
 export function classifyFailure(err, aborted) {
     const msg = err instanceof Error ? err.message : String(err);
@@ -29,6 +29,15 @@ export function classifyFailure(err, aborted) {
             level: 'error'
         };
     }
+    if (err instanceof ModelError) {
+        return {
+            state: 'failed',
+            reason: `model_error in ${err.phase}: ${err.cause.slice(0, 160)}`,
+            flash: 'model_error',
+            notify: `failed: ${err.phase} — model error: ${err.cause.slice(0, 120)}. Restart the model, then resume.`,
+            level: 'error'
+        };
+    }
     if (msg === 'no_verify_block') {
         return {
             state: 'failed',

package/dist/task/orchestrator.d.ts

@@ -69,6 +69,14 @@ export interface RunSingleTaskOptions {
      *  work. Lets callers record the id (e.g. stamp the /task-auto entry) so an
      *  interrupted run can be resumed instead of restarted. */
     onStart?: (taskId: string) => void | Promise<void>;
+    /**
+     * Ask the user for a steering message after they interrupt (ESC) the
+     * implementation turn. Return text to continue the same task as another turn,
+     * or undefined/empty to pause the run. Only consulted with
+     * waitForImplementation. Defaults to a ctx.ui.input prompt; injectable so the
+     * steer loop is testable without a real dialog.
+     */
+    promptSteer?: (ctx: ExtensionCommandContext) => Promise<string | undefined>;
 }
 export interface RunSingleTaskResult {
     taskId: string;
@@ -83,6 +91,16 @@ export interface RunSingleTaskResult {
      * only so test fakes that don't model session replacement can omit it.
      */
     ctx?: ExtensionCommandContext;
+    /**
+     * Set when the user interrupted the implementation (ESC) and then declined to
+     * steer (submitted an empty steer prompt) — i.e. they want the run to pause
+     * rather than continue. Only meaningful with waitForImplementation. The
+     * /task-auto loop reads this to pause (resumable) instead of checking the task
+     * off and advancing. A plain ESC that the user follows with steering text does
+     * NOT set this — that case loops on the same task until a turn finishes
+     * uninterrupted.
+     */
+    interrupted?: boolean;
 }
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and

package/dist/task/orchestrator.js

@@ -268,6 +268,50 @@ export class TaskRunner {
         }
     }
 }
+/** Dialog copy for the post-interrupt steering prompt. */
+const STEER_TITLE = 'Paused — steer the model';
+const STEER_PLACEHOLDER = 'Type guidance to continue this task, or leave empty to pause';
+/**
+ * True when the most recent assistant turn ended because the user interrupted it
+ * (pressed ESC). pi records a user abort as stopReason "aborted" on the assistant
+ * message, distinct from a natural "stop". Read after the implementation wait so
+ * the /task-auto loop can tell "user wants to steer" apart from "task finished".
+ */
+function wasInterrupted(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') {
+            return e.message.stopReason === 'aborted';
+        }
+    }
+    return false;
+}
+/**
+ * After the implementation turn settles, honour a user ESC by letting them steer.
+ *
+ * `waitForIdle` resolves both on natural completion AND on an ESC (which aborts
+ * the turn → idle). When the last turn was aborted, the host's main input loop is
+ * blocked inside our command handler, so a message typed in the editor would only
+ * queue, never run (interactive-mode routes idle input through onInputCallback,
+ * which is unset while we hold the loop). We therefore solicit the steering text
+ * ourselves and feed it back as another turn via sendUserMessage — which runs to
+ * completion when the session is idle. Repeat until a turn finishes uninterrupted.
+ *
+ * Returns true when the user declined to steer (empty/cancelled) and the run
+ * should pause; false when the implementation completed (steered or not).
+ */
+async function steerUntilDone(ctx, promptSteer) {
+    const ask = promptSteer ?? (c => c.ui.input(STEER_TITLE, STEER_PLACEHOLDER));
+    while (wasInterrupted(ctx)) {
+        const steer = await ask(ctx);
+        if (steer === undefined || steer.trim().length === 0)
+            return true; // pause
+        await ctx.sendUserMessage(steer);
+        await ctx.waitForIdle();
+    }
+    return false;
+}
 /**
  * Run one prompt through the full single-task pipeline in a fresh session and
  * deliver its spec. With waitForImplementation, block until the agent finishes
@@ -280,14 +324,17 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     // UI after the original ctx is torn down. Defaults to the original for the
     // cancellation path (where no replacement occurs).
     let freshCtx = ctx;
+    let interrupted = false;
     const result = await ctx.newSession({
         withSession: async (newCtx) => {
             freshCtx = newCtx;
             getBridge().currentCtx = newCtx; // keep remote dispatch ctx fresh across session replacement
             const runner = new TaskRunner(newCtx, cwd, rawPrompt, opts.resumeId, async (spec) => {
                 await newCtx.sendUserMessage(spec);
-                if (opts.waitForImplementation)
+                if (opts.waitForImplementation) {
                     await newCtx.waitForIdle();
+                    interrupted = await steerUntilDone(newCtx, opts.promptSteer);
+                }
             }, opts.spawnFn, opts.onStart);
             await runner.run();
             taskId = runner.taskId;
@@ -307,7 +354,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
             ok = false;
         }
     }
-    return { taskId, ok, sessionCancelled: false, ctx: freshCtx };
+    return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted };
 }
 // ─── Command handlers ────────────────────────────────────────────────────────
 async function handleTask(args, ctx) {

package/dist/task/phases.js

@@ -450,7 +450,7 @@ export async function critiqueWithFallback(d, p) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg !== 'no_verify_block')
             throw err;
-        p.ctx.ui.notify('Critique couldn\'t produce a VERIFY block — using compose draft. Edit the spec manually if needed.', 'warning');
+        p.ctx.ui.notify("Critique couldn't produce a VERIFY block — using compose draft. Edit the spec manually if needed.", 'warning');
         return p.spec;
     }
 }

package/dist/workers/docs-retrieve.js

@@ -14,10 +14,10 @@ function buildFtsQuery(tokens) {
 }
 function fallbackChunks(cache, name, version) {
     const dts = cache.db
-        .prepare('SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = \'dts\' ORDER BY file_path, id LIMIT 1')
+        .prepare("SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = 'dts' ORDER BY file_path, id LIMIT 1")
         .all(name, version);
     const readme = cache.db
-        .prepare('SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = \'readme\' ORDER BY id LIMIT 1')
+        .prepare("SELECT file_path, kind, content, 0 AS rank FROM chunks WHERE name = ? AND version = ? AND kind = 'readme' ORDER BY id LIMIT 1")
         .all(name, version);
     const out = [];
     for (const r of dts) {

package/package.json

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