@mjasnikovs/pi-task 0.13.11 → 0.13.12

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