@mjasnikovs/pi-task 0.2.0 → 0.2.2

package/README.md

@@ -61,6 +61,9 @@ pi install npm:@mjasnikovs/pi-task
 | `/task-list` | Open the task list in an editor dialog. |
 | `/task-resume [id]` | Resume the most recent (or named) unfinished task. |
 | `/task-cancel` | Cancel the running task (soft-terminal — still resumable). |
+| `/task-auto <feature>` | Plan a feature into a task list and run each title through `/task` in order (resumable). |
+| `/task-auto-resume` | Resume the active `/task-auto` run at the next unfinished task. |
+| `/task-auto-cancel` | Stop the `/task-auto` loop after the current task (still resumable). |
 
 ## The pipeline
 
@@ -74,6 +77,32 @@ pi install npm:@mjasnikovs/pi-task
 
 The finished spec is delivered to your main `pi` conversation via `sendUserMessage`, so you keep working in the same chat — no context handoff, no copy-paste.
 
+## Orchestrating multiple tasks — `/task-auto`
+
+A real feature is usually several tasks, not one. `/task-auto` is a thin planner on top of the single-task pipeline:
+
+```
+/task-auto add multi-tenant billing
+        │
+        ▼
+  ┌──────────┐   ┌──────────┐   ┌─────────────┐
+  │ clarify  │──▶│ decompose│──▶│ TASK_AUTO_…  │   resumable list of task titles
+  │ gray     │   │ → titles │   │ .md (titles) │
+  │ areas    │   └──────────┘   └──────┬───────┘
+  └──────────┘                         │
+                          ┌────────────▼─────────────┐
+                          │  for each unchecked title │
+                          │   → full /task pipeline    │  (spec + implement)
+                          │   → wait until it finishes │
+                          │   → check the box, next    │
+                          └────────────────────────────┘
+```
+
+- **It only produces titles.** All the depth — refine, research, grill, compose, critique — is `/task`'s job, run fresh per title. `/task-auto` never researches or specs anything itself.
+- **Clarify first.** It asks the few clarifying questions whose answers change how the feature splits, then decomposes the answers into an ordered list of task titles written to `.pi-tasks/TASK_AUTO_NNNN.md`.
+- **Sequential, blocking.** Each title runs through `/task` to a spec, the spec is implemented, and the loop waits for that to finish before starting the next title. No overlap.
+- **Crash- and cancel-safe.** Progress is the markdown checkboxes in the AUTO file. `/task-auto-resume` (no id) automatically picks up the active run at the first unchecked title. If a title's `/task` run fails, the loop stops and leaves the run resumable.
+
 ## Bundled tools
 
 `pi-task` also registers four MCP-style worker tools (formerly `@mjasnikovs/pi-worker`). All are parallel-execution-capable, so the parent session can issue several calls in one turn.

package/dist/index.js

@@ -1,6 +1,8 @@
 import { registerTask } from './task/orchestrator.js';
+import { registerTaskAuto } from './task/auto-orchestrator.js';
 import { registerWorkers } from './workers/index.js';
 export default function (pi) {
     registerTask(pi);
+    registerTaskAuto(pi);
     registerWorkers(pi);
 }

package/dist/shared/child-process.js

@@ -27,6 +27,14 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             stdio: ['ignore', 'pipe', 'pipe']
         });
         let firstByteFired = false;
+        // json-events lines can split across data chunks; this holds the trailing
+        // partial line between chunks so events spanning a boundary still parse.
+        // In json-events mode we deliberately do NOT accumulate the full raw
+        // stream: a long-running child emits hundreds of MB of events and
+        // `stdout += chunk` would overflow V8's max string length (≈512MB),
+        // crashing the process. We only need the parsed text, so we drop the raw
+        // bytes once drained.
+        let lineBuffer = '';
         proc.stdout?.on('data', (d) => {
             if (!firstByteFired) {
                 firstByteFired = true;
@@ -35,15 +43,22 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
             if (discardStdout)
                 return;
             const chunk = d.toString();
-            stdout += chunk;
             if (isJsonEvents) {
-                drainJsonEvents(chunk, opts);
+                lineBuffer = drainJsonEvents(lineBuffer + chunk, opts);
+            }
+            else {
+                stdout += chunk;
             }
         });
         proc.stderr?.on('data', (d) => {
             stderr += d.toString();
         });
         proc.on('close', (code) => {
+            // Flush a final event that wasn't newline-terminated.
+            if (isJsonEvents && lineBuffer.trim().length > 0) {
+                drainJsonEvents(lineBuffer + '\n', opts);
+                lineBuffer = '';
+            }
             const text = isJsonEvents ? (finalText || textDeltaAccum).trim() : undefined;
             resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
         });
@@ -65,8 +80,13 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                 signal.addEventListener('abort', kill, { once: true });
         }
         // ─── JSON event-stream processing ──────────────────────────────────
-        function drainJsonEvents(chunk, jsonOpts) {
-            let buf = chunk;
+        /**
+         * Parse every complete (newline-terminated) JSON line in `buf` and
+         * return the trailing partial line, which the caller carries into the
+         * next chunk. This avoids both losing events that span a chunk boundary
+         * and buffering the entire stream.
+         */
+        function drainJsonEvents(buf, jsonOpts) {
             let nl;
             while ((nl = buf.indexOf('\n')) !== -1) {
                 const line = buf.slice(0, nl).trim();
@@ -83,6 +103,7 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                     // Non-JSON line (startup banner, etc.) — ignore.
                 }
             }
+            return buf;
         }
         function handleEvent(evt, jsonOpts) {
             const t = typeof evt.type === 'string' ? evt.type : '';

package/dist/task/auto-commit.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Per-task git commit for /task-auto.
+ *
+ * After each decomposed task passes, runAutoLoop snapshots the working tree into
+ * a single commit so the run produces one commit per task. This is best-effort:
+ * outside a git repo, with nothing staged, or on any git error we report the
+ * reason and let the loop continue (the task already succeeded).
+ */
+import { type SpawnFn } from '../shared/child-process.js';
+export interface CommitResult {
+    committed: boolean;
+    /** Short, human-readable reason when committed === false. */
+    reason?: string;
+}
+/**
+ * Stage everything (`git add -A`) and commit it with `message`. Honors
+ * .gitignore via git itself. Never throws — failures surface as
+ * `{committed: false, reason}` so the caller can warn and keep going.
+ */
+export declare function gitCommitAll(cwd: string, message: string, signal?: AbortSignal, spawnFn?: SpawnFn): Promise<CommitResult>;

package/dist/task/auto-commit.js

@@ -0,0 +1,56 @@
+/**
+ * Per-task git commit for /task-auto.
+ *
+ * After each decomposed task passes, runAutoLoop snapshots the working tree into
+ * a single commit so the run produces one commit per task. This is best-effort:
+ * outside a git repo, with nothing staged, or on any git error we report the
+ * reason and let the loop continue (the task already succeeded).
+ */
+import { runChildDefault } from '../shared/child-process.js';
+function firstLine(s) {
+    const line = s.split('\n').find(l => l.trim().length > 0);
+    return (line ?? s).trim();
+}
+async function git(cwd, args, signal, spawnFn) {
+    const r = await runChildDefault({ command: 'git', args }, cwd, signal, { mode: 'text' }, spawnFn);
+    return { stdout: r.stdout, stderr: r.stderr, exitCode: r.exitCode, aborted: r.aborted };
+}
+/**
+ * Stage everything (`git add -A`) and commit it with `message`. Honors
+ * .gitignore via git itself. Never throws — failures surface as
+ * `{committed: false, reason}` so the caller can warn and keep going.
+ */
+export async function gitCommitAll(cwd, message, signal, spawnFn) {
+    // 1. Is this a git work tree at all?
+    const inside = await git(cwd, ['rev-parse', '--is-inside-work-tree'], signal, spawnFn);
+    if (inside.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (inside.exitCode !== 0 || inside.stdout.trim() !== 'true') {
+        return { committed: false, reason: 'not a git repository' };
+    }
+    // 2. Stage all working-tree changes (new, modified, deleted).
+    const add = await git(cwd, ['add', '-A'], signal, spawnFn);
+    if (add.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (add.exitCode !== 0) {
+        return { committed: false, reason: `git add failed: ${firstLine(add.stderr)}` };
+    }
+    // 3. Anything staged? `git diff --cached --quiet` exits 0 when the index
+    //    matches HEAD (nothing to commit), 1 when there are staged changes.
+    const diff = await git(cwd, ['diff', '--cached', '--quiet'], signal, spawnFn);
+    if (diff.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (diff.exitCode === 0)
+        return { committed: false, reason: 'nothing to commit' };
+    // 4. Commit. A failure here is usually missing user.name/user.email config.
+    const commit = await git(cwd, ['commit', '-m', message], signal, spawnFn);
+    if (commit.aborted)
+        return { committed: false, reason: 'cancelled' };
+    if (commit.exitCode !== 0) {
+        return {
+            committed: false,
+            reason: `git commit failed: ${firstLine(commit.stderr || commit.stdout)}`
+        };
+    }
+    return { committed: true };
+}

package/dist/task/auto-io.d.ts

@@ -0,0 +1,17 @@
+export interface TaskEntry {
+    index: number;
+    title: string;
+    done: boolean;
+    producedId?: string;
+}
+export declare function allocateAutoId(cwd: string): Promise<string>;
+/** Parse a decompose-phase model output into a clean list of titles. */
+export declare function parseDecomposeList(raw: string): string[];
+/** Parse the "## tasks" checkbox list. */
+export declare function parseTaskList(body: string): TaskEntry[];
+/** Build the initial AUTO-file body. */
+export declare function buildAutoBody(feature: string, clarifications: string, titles: string[]): string;
+/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
+export declare function checkOffTask(cwd: string, id: string, index: number, producedId: string, title: string): Promise<void>;
+/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
+export declare function findResumableAuto(cwd: string): Promise<string | null>;

package/dist/task/auto-io.js

@@ -0,0 +1,124 @@
+/**
+ * AUTO-file I/O & parsing for /task-auto.
+ *
+ * Thin layer over task-io/task-parsers: a TASK_AUTO_NNNN.md is a normal task
+ * file (same front matter) whose body holds feature prompt, clarifications, and
+ * a markdown checkbox list of task titles. The checkboxes are the resume cursor.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { tasksDir, ensureTasksDir, readTaskFile, setTaskSection } from './task-io.js';
+import { extractSection, parseFrontMatter } from './task-parsers.js';
+import { RESUMABLE_STATES } from './task-types.js';
+const AUTO_FILE_RE = /^(TASK_AUTO_\d{4,})\.md$/;
+const MAX_TASKS = 30;
+export async function allocateAutoId(cwd) {
+    await ensureTasksDir(cwd);
+    const entries = await fsp.readdir(tasksDir(cwd));
+    let max = 0;
+    for (const e of entries) {
+        const m = AUTO_FILE_RE.exec(e);
+        if (m) {
+            const n = parseInt(m[1].slice('TASK_AUTO_'.length), 10);
+            if (n > max)
+                max = n;
+        }
+    }
+    return `TASK_AUTO_${String(max + 1).padStart(4, '0')}`;
+}
+/** Parse a decompose-phase model output into a clean list of titles. */
+export function parseDecomposeList(raw) {
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const m = /^\s*(?:-\s*\[\s*[xX ]?\s*\]\s*|-\s+|\d+[.)]\s+)(.+?)\s*$/.exec(line);
+        if (m && m[1].trim().length > 0)
+            out.push(m[1].trim());
+        if (out.length >= MAX_TASKS)
+            break;
+    }
+    return out;
+}
+const CHECKBOX_RE = /^- \[([ xX])\]\s+(.+?)\s*$/;
+const PRODUCED_ID_RE = /^(TASK_\d{4,})\s{2,}(.+)$/;
+/** Parse the "## tasks" checkbox list. */
+export function parseTaskList(body) {
+    const section = extractSection(body, 'tasks');
+    if (section === null)
+        return [];
+    const entries = [];
+    let index = 0;
+    for (const line of section.split('\n')) {
+        const m = CHECKBOX_RE.exec(line.trim());
+        if (!m)
+            continue;
+        const done = m[1].toLowerCase() === 'x';
+        const rest = m[2].trim();
+        if (done) {
+            const idm = PRODUCED_ID_RE.exec(rest);
+            if (idm) {
+                entries.push({ index, title: idm[2].trim(), done: true, producedId: idm[1] });
+            }
+            else {
+                entries.push({ index, title: rest, done: true });
+            }
+        }
+        else {
+            entries.push({ index, title: rest, done: false });
+        }
+        index++;
+    }
+    return entries;
+}
+/** Build the initial AUTO-file body. */
+export function buildAutoBody(feature, clarifications, titles) {
+    const tasks = titles.map(t => `- [ ] ${t}`).join('\n');
+    return (`\n## feature prompt\n\n${feature.trim() || '(none)'}\n\n`
+        + `## clarifications\n\n${clarifications.trim() || '(none)'}\n\n`
+        + `## tasks\n\n${tasks}\n`);
+}
+/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
+export async function checkOffTask(cwd, id, index, producedId, title) {
+    const { body } = await readTaskFile(cwd, id);
+    const section = extractSection(body, 'tasks') ?? '';
+    const lines = section.split('\n');
+    let seen = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (!CHECKBOX_RE.test(lines[i].trim()))
+            continue;
+        seen++;
+        if (seen === index) {
+            lines[i] = producedId ? `- [x] ${producedId}  ${title}` : `- [x] ${title}`;
+            break;
+        }
+    }
+    if (seen < index) {
+        throw new Error(`checkOffTask: index ${index} out of range in ${id} (only ${seen + 1} checkboxes found)`);
+    }
+    await setTaskSection(cwd, id, 'tasks', lines.join('\n'));
+}
+/** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
+export async function findResumableAuto(cwd) {
+    await ensureTasksDir(cwd);
+    const entries = await fsp.readdir(tasksDir(cwd));
+    const candidates = [];
+    for (const f of entries) {
+        const m = AUTO_FILE_RE.exec(f);
+        if (!m)
+            continue;
+        try {
+            const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+            const fm = parseFrontMatter(raw);
+            if (!fm)
+                continue;
+            if (!RESUMABLE_STATES.includes(fm.state))
+                continue;
+            const st = await fsp.stat(path.join(tasksDir(cwd), f));
+            candidates.push({ id: m[1], mtime: st.mtimeMs });
+        }
+        catch {
+            /* skip unreadable */
+        }
+    }
+    candidates.sort((a, b) => b.mtime - a.mtime);
+    return candidates.length > 0 ? candidates[0].id : null;
+}

package/dist/task/auto-orchestrator.d.ts

@@ -0,0 +1,28 @@
+import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { RunSingleTaskResult } from './orchestrator.js';
+import { type CommitResult } from './auto-commit.js';
+/**
+ * Injectable seams so the planner and loop are testable without spawning pi.
+ * `runChild` is used by planAuto; `runTask` is used by runAutoLoop.
+ */
+export interface AutoDeps {
+    runChild: (name: string, tools: string, prompt: string) => Promise<string>;
+    runTask: (ctx: ExtensionCommandContext, cwd: string, title: string) => Promise<RunSingleTaskResult>;
+    /** Snapshot the working tree into one commit after a task passes. */
+    commit: (cwd: string, message: string) => Promise<CommitResult>;
+}
+/**
+ * Expand any @file references in the feature text by appending each referenced
+ * file's contents, so the planning children (clarify, decompose) always see the
+ * real spec inline instead of relying on the model to open the file itself.
+ * Without this, clarify on a one-line "Implement @spec.md" tends to bail with
+ * NONE because, to the model, the request looks small and unambiguous.
+ * Unreadable mentions (typos, non-file @tokens) are left untouched; the feature
+ * is returned verbatim when nothing readable is referenced.
+ */
+export declare function expandFeatureMentions(cwd: string, feature: string): Promise<string>;
+/** Plan phase: clarify → decompose → write AUTO file. Returns the new id, or null. */
+export declare function planAuto(ctx: ExtensionCommandContext, cwd: string, feature: string, deps: AutoDeps): Promise<string | null>;
+export declare function requestAutoCancel(): void;
+export declare function runAutoLoop(ctx: ExtensionCommandContext, cwd: string, id: string, deps: AutoDeps): Promise<void>;
+export declare function registerTaskAuto(pi: ExtensionAPI): void;

package/dist/task/auto-orchestrator.js

@@ -0,0 +1,298 @@
+/**
+ * /task-auto — plans a feature into a resumable list of task titles, then runs
+ * each title through the existing single-task pipeline one at a time.
+ *
+ * This module currently holds the planning half (AutoDeps + planAuto). The run
+ * loop, command handlers, and defaultDeps are added by the next task.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { runSingleTask } from './orchestrator.js';
+import { parseClarifyList, deriveTitle } from './parsers.js';
+import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
+import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
+import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, findResumableAuto } from './auto-io.js';
+import { writeTaskFile, readTaskFile, updateTaskFrontMatter } from './task-io.js';
+import { gitCommitAll } from './auto-commit.js';
+import { runPhaseChild, USER_CANCELLED } from './child-runner.js';
+import { startAutoLoader } from './widget.js';
+// Matches pi's @-file completion token (a path after @, until whitespace).
+const MENTION_RE = /(?:^|\s)@([^\s]+)/g;
+/**
+ * Expand any @file references in the feature text by appending each referenced
+ * file's contents, so the planning children (clarify, decompose) always see the
+ * real spec inline instead of relying on the model to open the file itself.
+ * Without this, clarify on a one-line "Implement @spec.md" tends to bail with
+ * NONE because, to the model, the request looks small and unambiguous.
+ * Unreadable mentions (typos, non-file @tokens) are left untouched; the feature
+ * is returned verbatim when nothing readable is referenced.
+ */
+export async function expandFeatureMentions(cwd, feature) {
+    const seen = new Set();
+    const blocks = [];
+    for (const m of feature.matchAll(MENTION_RE)) {
+        const rel = m[1];
+        if (seen.has(rel))
+            continue;
+        seen.add(rel);
+        try {
+            const body = await fsp.readFile(path.resolve(cwd, rel), 'utf8');
+            if (body.trim().length > 0) {
+                blocks.push(`--- contents of ${rel} ---\n${body.trim()}`);
+            }
+        }
+        catch {
+            // not a readable file — leave the @token in place, skip expansion
+        }
+    }
+    return blocks.length === 0 ? feature : `${feature.trim()}\n\n${blocks.join('\n\n')}`;
+}
+/** Plan phase: clarify → decompose → write AUTO file. Returns the new id, or null. */
+export async function planAuto(ctx, cwd, feature, deps) {
+    // clarify — sequential & adaptive: ask one question at a time, feeding every
+    // answer back into the next call so later questions react to earlier ones
+    // (e.g. a framework choice reshapes what gets asked). Each question is shown
+    // with the model's recommended default pre-filled (Enter to accept, type to
+    // override); we never auto-answer. The model emits NONE when nothing remains.
+    const theme = ctx.ui.theme;
+    // Inline any @file spec the user referenced so clarify/decompose reason over
+    // the real content, not a one-line "Implement @file" that reads as trivial.
+    const featureForModel = await expandFeatureMentions(cwd, feature);
+    const answers = [];
+    // Open-ended: keep asking until the model emits NONE or the user dismisses.
+    for (;;) {
+        const qRaw = await deps.runChild('auto-clarify', 'read', AUTO_CLARIFY_PROMPT(featureForModel, answers.join('\n')));
+        const parsed = parseClarifyList(qRaw);
+        if (parsed.length === 0)
+            break; // NONE / nothing left to ask
+        const { question, suggested } = parsed[0];
+        // Render markdown (bold/code) for the displayed prompt; keep plain text
+        // for the editable default and the persisted file.
+        const shownQ = renderInlineMarkdown(question, theme);
+        const plainQ = stripInlineMarkdown(question);
+        const plainSuggested = suggested === undefined ? undefined : stripInlineMarkdown(suggested);
+        const title = suggested ?
+            `${shownQ}\n${theme.fg('muted', 'Recommended:')}\n\n${renderInlineMarkdown(suggested, theme)}\n\n${theme.fg('muted', 'press Enter to accept')}`
+            : `${shownQ}\n${theme.fg('muted', '(no recommendation — please answer)')}`;
+        const a = await ctx.ui.input(title, plainSuggested);
+        if (a === undefined) {
+            ctx.ui.notify('/task-auto cancelled.', 'warning');
+            return null;
+        }
+        const typed = a.trim();
+        let answer;
+        if (typed.length === 0 && plainSuggested) {
+            answer = `${plainSuggested} (accepted recommendation)`;
+        }
+        else if (typed.length === 0) {
+            answer = '(skipped)';
+        }
+        else {
+            answer = typed;
+        }
+        answers.push(`Q${answers.length + 1}: ${plainQ}\nA${answers.length + 1}: ${answer}`);
+    }
+    if (answers.length === 0) {
+        ctx.ui.notify('No clarifying questions needed — planning tasks…', 'info');
+    }
+    const clarifications = answers.join('\n');
+    // decompose
+    const listRaw = await deps.runChild('auto-decompose', 'read', AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications));
+    const titles = parseDecomposeList(listRaw);
+    if (titles.length === 0) {
+        ctx.ui.notify('/task-auto: no tasks produced from the feature.', 'warning');
+        return null;
+    }
+    // persist
+    const id = await allocateAutoId(cwd);
+    const now = new Date().toISOString();
+    const fm = {
+        id,
+        state: 'in_progress',
+        phase: 'done',
+        created_at: now,
+        updated_at: now,
+        title: deriveTitle(feature)
+    };
+    await writeTaskFile(cwd, fm, buildAutoBody(feature, clarifications, titles));
+    return id;
+}
+/** The two feature-level planning children, shown as steps in the loader. */
+const AUTO_PLAN_STEPS = {
+    'auto-clarify': { step: 'clarify', stepNum: 1 },
+    'auto-decompose': { step: 'decompose', stepNum: 2 }
+};
+const AUTO_PLAN_STEP_TOTAL = 2;
+function defaultDeps(ctx, cwd, signal, title) {
+    // Captured by the loader's getState so the widget mirrors the child's latest
+    // output line and context usage, exactly like the single-task phase widget.
+    let lastLine;
+    let contextUsage;
+    const parentContextWindow = ctx.model?.contextWindow ?? 0;
+    const phaseDeps = {
+        cwd,
+        taskId: '',
+        signal,
+        onChildOutput: (line) => {
+            lastLine = line;
+        },
+        onContextUsage: snapshot => {
+            const cw = snapshot.contextWindow > 0 ?
+                snapshot.contextWindow
+                : contextUsage?.contextWindow || parentContextWindow;
+            const percent = cw > 0 ? Math.min(100, (snapshot.tokens / cw) * 100) : snapshot.percent;
+            contextUsage = { tokens: snapshot.tokens, contextWindow: cw, percent };
+        }
+    };
+    return {
+        runChild: async (name, tools, prompt) => {
+            // Planning children are slow LLM calls with no UI of their own; show
+            // the same status block as /task so this never goes silent until the
+            // drill dialog.
+            lastLine = undefined;
+            contextUsage = undefined;
+            const startedAt = Date.now();
+            const { step, stepNum } = AUTO_PLAN_STEPS[name] ?? { step: name, stepNum: 1 };
+            const stopLoader = startAutoLoader(ctx, () => ({
+                title,
+                step,
+                stepNum,
+                stepTotal: AUTO_PLAN_STEP_TOTAL,
+                startedAt,
+                lastLine,
+                contextUsage
+            }));
+            try {
+                return await runPhaseChild(phaseDeps, name, tools, prompt);
+            }
+            finally {
+                stopLoader();
+            }
+        },
+        runTask: (c, cwd2, t) => runSingleTask(c, cwd2, t, { waitForImplementation: true }),
+        commit: (cwd2, message) => gitCommitAll(cwd2, message, signal)
+    };
+}
+// ─── Loop ────────────────────────────────────────────────────────────────────
+let cancelRequested = false;
+export function requestAutoCancel() {
+    cancelRequested = true;
+}
+export async function runAutoLoop(ctx, cwd, id, deps) {
+    cancelRequested = false;
+    // Each task runs in its own fresh session (deps.runTask → ctx.newSession),
+    // which tears down the current session and leaves the ctx we passed in stale.
+    // Adopt the replacement ctx the runner hands back and use it for all further
+    // UI and the next task — reusing the captured ctx throws "stale ctx".
+    let active = ctx;
+    try {
+        for (;;) {
+            if (cancelRequested) {
+                active.ui.notify(`${id} cancelled — resume with /task-auto-resume.`, 'warning');
+                return;
+            }
+            const { body } = await readTaskFile(cwd, id);
+            const entries = parseTaskList(body);
+            const next = entries.find(e => !e.done);
+            if (!next) {
+                await updateTaskFrontMatter(cwd, id, { state: 'completed' });
+                active.ui.notify(`${id} complete — all ${entries.length} tasks done.`, 'info');
+                return;
+            }
+            active.ui.notify(`${id}: task ${next.index + 1}/${entries.length} — ${next.title}`, 'info');
+            const res = await deps.runTask(active, cwd, next.title);
+            active = res.ctx ?? active;
+            if (res.sessionCancelled) {
+                active.ui.notify(`${id} paused — could not start a session. Run /task-auto-resume to retry.`, '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');
+                return;
+            }
+            // res.ok === true means runner.run() completed, so res.taskId is the
+            // allocated TASK_NNNN id (never empty here). checkOffTask tolerates an
+            // empty id by writing a plain checked line, but that path is unreachable.
+            await checkOffTask(cwd, id, next.index, res.taskId, next.title);
+            // Commit the task's work (and the just-written check-off) as one
+            // snapshot. Best-effort: a failed/empty commit only warns — the task
+            // already passed, so the run continues.
+            const message = `task: ${next.title} (${res.taskId})`;
+            const commit = await deps.commit(cwd, message);
+            if (commit.committed) {
+                active.ui.notify(`${id}: committed "${next.title}".`, 'info');
+            }
+            else {
+                active.ui.notify(`${id}: not committed (${commit.reason ?? 'unknown'}) — continuing.`, 'warning');
+            }
+        }
+    }
+    finally {
+        cancelRequested = false;
+    }
+}
+// ─── Command handlers ────────────────────────────────────────────────────────
+async function handleTaskAuto(args, ctx) {
+    await ctx.waitForIdle();
+    const cwd = ctx.cwd;
+    const raw = args.trim();
+    if (raw.length === 0) {
+        ctx.ui.setEditorText('/task-auto ');
+        ctx.ui.notify('Describe the feature after /task-auto (use @ for file completion).', 'info');
+        return;
+    }
+    const abort = new AbortController();
+    const deps = defaultDeps(ctx, cwd, abort.signal, deriveTitle(raw));
+    let id;
+    try {
+        id = await planAuto(ctx, cwd, raw, deps);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg === USER_CANCELLED) {
+            ctx.ui.notify('/task-auto cancelled.', 'warning');
+            return;
+        }
+        ctx.ui.notify(`/task-auto planning failed: ${msg}`, 'error');
+        return;
+    }
+    if (!id)
+        return;
+    await runAutoLoop(ctx, cwd, id, deps);
+}
+async function handleTaskAutoResume(_args, ctx) {
+    await ctx.waitForIdle();
+    const cwd = ctx.cwd;
+    const id = await findResumableAuto(cwd);
+    if (!id) {
+        ctx.ui.notify('No resumable /task-auto run.', 'info');
+        return;
+    }
+    ctx.ui.notify(`Resuming ${id}…`, 'info');
+    await updateTaskFrontMatter(cwd, id, { state: 'in_progress' });
+    const abort = new AbortController();
+    // Resume only runs the loop (runTask); no planning children, so the loader
+    // title is unused here — pass the id for clarity if that ever changes.
+    await runAutoLoop(ctx, cwd, id, defaultDeps(ctx, cwd, abort.signal, id));
+}
+// eslint-disable-next-line @typescript-eslint/require-await
+async function handleTaskAutoCancel(_args, ctx) {
+    requestAutoCancel();
+    ctx.ui.notify('Stopping /task-auto after the current task…', 'warning');
+}
+// ─── Registration ────────────────────────────────────────────────────────────
+export function registerTaskAuto(pi) {
+    pi.registerCommand('task-auto', {
+        description: 'Plan a feature into tasks and run them. Usage: /task-auto <feature>',
+        handler: handleTaskAuto
+    });
+    pi.registerCommand('task-auto-resume', {
+        description: 'Resume the active /task-auto run.',
+        handler: handleTaskAutoResume
+    });
+    pi.registerCommand('task-auto-cancel', {
+        description: 'Stop the running /task-auto loop after the current task.',
+        handler: handleTaskAutoCancel
+    });
+}