@mjasnikovs/pi-task 0.14.11 → 0.14.13

package/dist/config/config.d.ts

@@ -4,6 +4,7 @@ export interface PiTaskConfig {
     autoCommit: boolean;
     orientation: boolean;
     enforceGuidelines: boolean;
+    verifyWork: boolean;
 }
 export declare function getConfig(): PiTaskConfig;
 export declare function saveConfig(config: PiTaskConfig): Promise<void>;

package/dist/config/config.js

@@ -7,7 +7,8 @@ const DEFAULTS = {
     compressReasoning: true,
     autoCommit: true,
     orientation: true,
-    enforceGuidelines: false
+    enforceGuidelines: false,
+    verifyWork: false
 };
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;

package/dist/config/register.js

@@ -22,6 +22,11 @@ const ITEMS = [
         id: 'enforceGuidelines',
         label: 'enforce guidelines',
         description: 'Before each /task-auto commit, re-check the work against AGENTS.md/CLAUDE.md and fix drift'
+    },
+    {
+        id: 'verifyWork',
+        label: 'verify work',
+        description: "After each /task-auto task, RUN its spec's VERIFY block in the workspace and report a PASS/FAIL verdict"
     }
 ];
 function makeTheme(theme) {

package/dist/remote/bridge.d.ts

@@ -20,6 +20,9 @@ export declare function answerPrompt(id: string, value: string | undefined): voi
 export interface AskSpec {
     /** Themed, possibly multi-line title for the local TUI input. */
     localTitle: string;
+    /** Themed (markdown-rendered) question shown as the boxed picker header.
+     *  Falls back to `question` when absent. */
+    displayQuestion?: string;
     /** Plain question text for the browser card. */
     question: string;
     /** Primary recommended option, prefilled in the local TUI. */
@@ -52,12 +55,12 @@ export declare class SessionUI {
     /** Race the local input against a remote answer; first to settle wins. */
     ask(spec: AskSpec): Promise<string | undefined>;
     /**
-     * The local-TUI half of ask(). With `spec.options` it renders a select()
-     * picker (each option on its own line) plus a trailing "type a different
-     * answer" entry that drops to a text input; the chosen entry's `value` is
-     * returned. Without options it falls back to a single text input. Cancelling
-     * either dialog (or an abort when the remote wins the race) resolves to
-     * undefined.
+     * The local-TUI half of ask(). With `spec.options` it renders the boxed
+     * picker (each answer in its own bounding box, the first/recommended one
+     * tinted green) plus a trailing "type a different answer" entry that drops to
+     * a text input; the chosen entry's `value` is returned. Without options it
+     * falls back to a single text input. Cancelling either dialog (or an abort
+     * when the remote wins the race) resolves to undefined.
      */
     private askLocal;
 }

package/dist/remote/bridge.js

@@ -1,6 +1,7 @@
 import { broadcast as wsBroadcast } from './broadcast.js';
 import { pushNotify } from './push.js';
 import { setPrompt, clearPrompt } from './session-state.js';
+import { askQuestionBox } from '../task/question-box.js';
 const g = globalThis;
 export function getBridge() {
     if (!g.__piBridge) {
@@ -25,9 +26,6 @@ export function answerPrompt(id, value) {
     b.pending.delete(id);
     settle(value);
 }
-/** Trailing picker entry that drops to a free-text input — the local mirror of
- *  the remote card's "✎ Manual answer" button. */
-const TYPE_OWN_LABEL = 'Type a different answer…';
 /** Wraps a live command ctx and fans interactions out to local TUI + browsers. */
 export class SessionUI {
     ctx;
@@ -83,27 +81,26 @@ export class SessionUI {
         }
     }
     /**
-     * The local-TUI half of ask(). With `spec.options` it renders a select()
-     * picker (each option on its own line) plus a trailing "type a different
-     * answer" entry that drops to a text input; the chosen entry's `value` is
-     * returned. Without options it falls back to a single text input. Cancelling
-     * either dialog (or an abort when the remote wins the race) resolves to
-     * undefined.
+     * The local-TUI half of ask(). With `spec.options` it renders the boxed
+     * picker (each answer in its own bounding box, the first/recommended one
+     * tinted green) plus a trailing "type a different answer" entry that drops to
+     * a text input; the chosen entry's `value` is returned. Without options it
+     * falls back to a single text input. Cancelling either dialog (or an abort
+     * when the remote wins the race) resolves to undefined.
      */
     async askLocal(spec, signal) {
         const opts = spec.options;
         if (opts && opts.length > 0) {
-            const labels = opts.map(o => o.label);
-            const choice = await this.ctx.ui.select(spec.localTitle, [...labels, TYPE_OWN_LABEL], {
+            return askQuestionBox(this.ctx, {
+                question: spec.displayQuestion ?? spec.question,
+                inputTitle: spec.localTitle,
+                options: opts.map((o, i) => ({
+                    label: o.label,
+                    value: o.value,
+                    recommended: i === 0
+                })),
                 signal
             });
-            if (choice === undefined)
-                return undefined; // cancelled / aborted
-            if (choice === TYPE_OWN_LABEL) {
-                return this.ctx.ui.input(spec.localTitle, undefined, { signal });
-            }
-            const hit = opts.find(o => o.label === choice);
-            return hit ? hit.value : choice;
         }
         return this.ctx.ui.input(spec.localTitle, spec.recommended, { signal });
     }

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

@@ -2,6 +2,7 @@ import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-c
 import type { RunSingleTaskResult } from './orchestrator.js';
 import { type CommitResult } from './auto-commit.js';
 import { type EnforceOutcome } from './enforce-guidelines.js';
+import { type VerifyOutcome } from './verify-work.js';
 /**
  * Injectable seams so the planner and loop are testable without spawning pi.
  * `runChild` is used by planAuto; `runTask` is used by runAutoLoop.
@@ -29,6 +30,16 @@ export interface AutoDeps {
      * enforcement runs and using it for the loader widget throws "stale ctx".
      */
     enforce?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string) => Promise<EnforceOutcome>;
+    /**
+     * Verify the just-finished task's work by RUNNING its composed spec's VERIFY
+     * block in the real workspace (a fresh child of the same local model, with a
+     * `bash` tool), then reporting a PASS/FAIL verdict. Optional: absent in tests
+     * or when the `verifyWork` flag is off, in which case the loop treats it as a
+     * pass. Runs BEFORE the task is checked off/committed and is a hard GATE: ok
+     * === false stops the run and fails the task (left unchecked so resume re-runs
+     * it). Needs the inner taskId to read that task's spec.
+     */
+    verify?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string) => Promise<VerifyOutcome>;
 }
 /**
  * Expand any @file references in the feature text by appending each referenced

package/dist/task/auto-orchestrator.js

@@ -16,6 +16,7 @@ import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, check
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
 import { gitCommitAll } from './auto-commit.js';
 import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
+import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { runWorker } from '../workers/pi-worker-core.js';
 import { findPhantomImports, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { runPhaseChild, prependHint, formatLoopHint, USER_CANCELLED } from './child-runner.js';
@@ -246,30 +247,30 @@ export async function planAuto(ctx, cwd, feature, deps) {
         askedQuestions.push(plainQ);
         const plainSuggested = suggested === undefined ? undefined : stripInlineMarkdown(suggested);
         const plainAlt = alt === undefined ? undefined : stripInlineMarkdown(alt);
-        // Identical to /task's grill dialog: a binary fork becomes a select()
-        // picker locally — each option on its own line, labelled A/B; a single
-        // recommendation rides under the question as the input default; an open
-        // question shows the bare prompt. No verbose "Recommended:" /
-        // "press Enter to accept" scaffolding.
+        // Identical to /task's grill dialog: a recommendation (or A/B fork)
+        // becomes the boxed picker locally — each answer in its own bounding box,
+        // the recommended one tinted green; an open question shows the bare text
+        // prompt. No verbose "Recommended:" / "press Enter to accept" scaffolding.
         const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
-        const title = !twoOption && plainSuggested ?
-            `${shownQ}\n${renderInlineMarkdown(suggested, theme)}`
-            : shownQ;
+        const options = twoOption ?
+            [
+                {
+                    label: `A: ${renderInlineMarkdown(suggested, theme)}`,
+                    value: plainSuggested
+                },
+                { label: `B: ${renderInlineMarkdown(alt, theme)}`, value: plainAlt }
+            ]
+            : plainSuggested !== undefined ?
+                [{ label: renderInlineMarkdown(suggested, theme), value: plainSuggested }]
+                : undefined;
         const a = await ui.ask({
-            localTitle: title,
+            localTitle: shownQ,
+            displayQuestion: shownQ,
             question: plainQ,
             recommended: plainSuggested,
             ...(plainAlt !== undefined && { recommended2: plainAlt }),
             allowSkip: plainSuggested === undefined && plainAlt === undefined,
-            ...(twoOption && {
-                options: [
-                    {
-                        label: `A: ${renderInlineMarkdown(suggested, theme)}`,
-                        value: plainSuggested
-                    },
-                    { label: `B: ${renderInlineMarkdown(alt, theme)}`, value: plainAlt }
-                ]
-            })
+            ...(options && { options })
         });
         if (a === undefined) {
             announceDone(ctx, '/task-auto cancelled.', 'warning');
@@ -292,6 +293,11 @@ export async function planAuto(ctx, cwd, feature, deps) {
         else if (twoOption && /^b[.)]?$/i.test(typed)) {
             answer = plainAlt;
         }
+        else if (!twoOption && plainSuggested !== undefined && typed === plainSuggested) {
+            // Single recommendation accepted by picking its (green) card in the
+            // boxed picker — same provenance as an empty-submit accept.
+            answer = `${plainSuggested} (accepted recommendation)`;
+        }
         else {
             answer = typed;
         }
@@ -476,6 +482,86 @@ function defaultDeps(ctx, cwd, signal, title) {
                     }
                 }
             });
+        },
+        verify: async (verifyCtx, cwd2, taskTitle, taskId) => {
+            if (!getConfig().verifyWork) {
+                return { ok: true, reason: 'disabled' };
+            }
+            // The spec to verify against is the composed spec committed in the
+            // task file. A task that never reached compose has no spec section —
+            // runWorkVerification treats a null spec as a no-op pass.
+            let spec;
+            try {
+                const { body } = await readTaskFile(cwd2, taskId);
+                spec = extractSpecForVerification(body);
+            }
+            catch {
+                spec = null;
+            }
+            return runWorkVerification({
+                cwd: cwd2,
+                signal,
+                spec,
+                // Same unguarded child as enforce: no wall-clock timeout (a build
+                // or test suite legitimately takes minutes) and exact-match loop
+                // guard only. Re-running the same VERIFY command is the job, so the
+                // path-revisit heuristic is disabled; only a literally-identical
+                // call repeated past threshold trips, and that warns rather than
+                // blocks.
+                runChild: async (tools, prompt, sig) => {
+                    lastLine = undefined;
+                    contextUsage = undefined;
+                    const startedAt = Date.now();
+                    const verifyLogPath = path.join(tasksDir(cwd2), 'verify-debug.log');
+                    const logVerify = (msg) => {
+                        void fsp
+                            .appendFile(verifyLogPath, `${new Date().toISOString()} ${msg}\n`)
+                            .catch(() => { });
+                    };
+                    logVerify(`=== verify start: ${taskTitle} ===`);
+                    const stopLoader = startAutoLoader(verifyCtx, () => ({
+                        title: taskTitle,
+                        kind: 'verify',
+                        step: 'verify',
+                        stepNum: 1,
+                        stepTotal: 1,
+                        startedAt,
+                        lastLine,
+                        contextUsage
+                    }));
+                    try {
+                        const r = await runWorker({
+                            prompt,
+                            cwd: cwd2,
+                            signal: sig,
+                            tools,
+                            timeoutMs: 0,
+                            loop: { pathThreshold: Number.POSITIVE_INFINITY },
+                            onLine: line => {
+                                lastLine = line;
+                                logVerify(line);
+                            },
+                            onContextUsage: snapshot => {
+                                contextUsage = resolveContextUsage(snapshot, contextUsage, parentContextWindow);
+                            }
+                        });
+                        if (r.loopHit) {
+                            logVerify(`=== verify LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
+                            verifyCtx.ui.notify(`${taskTitle}: verify worker looped past the nudges — continuing (not blocked).`, 'warning');
+                        }
+                        const failure = classifyEnforceChildFailure(r);
+                        logVerify(failure ?
+                            `=== verify end: FAIL — ${failure} ===`
+                            : '=== verify end: verdict captured ===');
+                        if (failure)
+                            throw new Error(failure);
+                        return r.text;
+                    }
+                    finally {
+                        stopLoader();
+                    }
+                }
+            });
         }
     };
 }
@@ -581,6 +667,24 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 announceDone(active, `${id} stopped at "${next.title}"${why} — fix and run /task-auto-resume.`, 'error');
                 return;
             }
+            // GATE: actually RUN the task's verification against the just-finished
+            // work BEFORE it is checked off or committed. The composed spec ships a
+            // VERIFY block, but nothing in the pipeline ever executed it — a task
+            // that did not work was checked off identically to one that did. Run it
+            // now in the real workspace; a FAIL stops the whole run exactly like an
+            // implementation failure — the task is left UNCHECKED and UNCOMMITTED so
+            // /task-auto-resume re-runs it (rather than blessing broken work). Off
+            // by default (deps.verify returns a disabled no-op) and a no-op when the
+            // task has no composed spec to verify against.
+            if (deps.verify) {
+                active.ui.notify(`${id}: verifying "${next.title}"…`, 'info');
+                const verified = await deps.verify(active, cwd, next.title, res.taskId);
+                if (!verified.ok) {
+                    await updateTaskFrontMatter(cwd, id, { state: 'failed' });
+                    announceDone(active, `${id} stopped at "${next.title}" — ${verified.reason ?? 'did not verify'} — 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.

package/dist/task/phases.js

@@ -517,30 +517,30 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
         else {
             const plainSuggested = auto.suggested === undefined ? undefined : stripInlineMarkdown(auto.suggested);
             const plainAlt = auto.alt === undefined ? undefined : stripInlineMarkdown(auto.alt);
-            // A binary fork (suggested + alt) becomes a select() picker locally —
-            // each option on its own line, labelled A/B. A single recommendation
-            // rides along under the question as the input default; an open
-            // question shows the bare prompt.
+            // A recommendation (or suggested+alt fork) becomes the boxed picker
+            // locally — each answer in its own bounding box, the recommended one
+            // tinted green; an open question shows the bare text prompt.
             const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
-            const localTitle = !twoOption && plainSuggested ?
-                `${shownQ}\n${renderInlineMarkdown(auto.suggested, theme)}`
-                : shownQ;
+            const options = twoOption ?
+                [
+                    {
+                        label: `A: ${renderInlineMarkdown(auto.suggested, theme)}`,
+                        value: plainSuggested
+                    },
+                    { label: `B: ${renderInlineMarkdown(auto.alt, theme)}`, value: plainAlt }
+                ]
+                : plainSuggested !== undefined ?
+                    [{ label: renderInlineMarkdown(auto.suggested, theme), value: plainSuggested }]
+                    : undefined;
             widgetState.lastLine = `awaiting Q${n + 1}`;
             const a = await ui.ask({
-                localTitle,
+                localTitle: shownQ,
+                displayQuestion: shownQ,
                 question: plainQ,
                 recommended: plainSuggested,
                 recommended2: plainAlt,
                 allowSkip: plainSuggested === undefined && plainAlt === undefined,
-                ...(twoOption && {
-                    options: [
-                        {
-                            label: `A: ${renderInlineMarkdown(auto.suggested, theme)}`,
-                            value: plainSuggested
-                        },
-                        { label: `B: ${renderInlineMarkdown(auto.alt, theme)}`, value: plainAlt }
-                    ]
-                })
+                ...(options && { options })
             });
             if (a === undefined)
                 throw new Error(USER_CANCELLED);

package/dist/task/question-box.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Boxed question dialog for the clarify / grill phases.
+ *
+ * The built-in `ctx.ui.select` renders every option as a bare line under one
+ * outer frame — the question, the recommendation, and the choices all read as a
+ * single blob. The remote (browser) prompt card instead gives each response its
+ * own bounded panel, tints the recommended one green, and separates everything
+ * with margins. This module mirrors that remote style in the terminal: a custom
+ * `ctx.ui.custom` component that draws each answer in its own bounding box with a
+ * green RECOMMENDED tag, an accent-highlighted cursor box, and clear vertical
+ * spacing.
+ *
+ * `renderQuestionBox` is the pure layout — width in, lines out — so the visual
+ * structure (borders, tag, cursor arrow, padding) is unit-testable without a
+ * live TUI. The component and `askQuestionBox` wire it to keyboard input and the
+ * "type a different answer" free-text fallback.
+ */
+import type { Component } from '@earendil-works/pi-tui';
+import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+/** One answer card. `label` may carry ANSI (rendered markdown); width math is
+ *  ANSI-aware so the box borders still line up. */
+export interface BoxCard {
+    label: string;
+    /** Recommended answer → green chrome + RECOMMENDED tag. */
+    recommended?: boolean;
+}
+/** Chrome colourers, injected so tests can pass identity fns and assert on the
+ *  plain box structure. A real theme is adapted by {@link boxColors}. */
+export interface BoxColors {
+    border: (s: string) => string;
+    borderRecommended: (s: string) => string;
+    borderSelected: (s: string) => string;
+    recommendedTag: (s: string) => string;
+    questionLabel: (s: string) => string;
+    hint: (s: string) => string;
+    arrow: (s: string) => string;
+}
+type ThemeLike = ExtensionCommandContext['ui']['theme'];
+export declare const QUESTION_LABEL = "QUESTION";
+export declare const HINT_TEXT = "\u2191\u2193 navigate \u00B7 enter select \u00B7 esc cancel";
+export declare const MANUAL_CARD_LABEL = "\u270E Type a different answer\u2026";
+/**
+ * Lay the whole dialog out for `width` columns: a QUESTION label + wrapped
+ * question, one bounding box per card (recommended tinted green, the cursor box
+ * highlighted with an accent border and "▸" arrow), and a key-hint footer.
+ */
+export declare function renderQuestionBox(width: number, question: string, cards: BoxCard[], selected: number, c: BoxColors, hintText?: string): string[];
+export declare function boxColors(theme: ThemeLike): BoxColors;
+/** Focusable picker component; navigation mirrors the built-in select dialog. */
+export declare class QuestionBoxComponent implements Component {
+    private readonly question;
+    private readonly cards;
+    private readonly colors;
+    private readonly onChoose;
+    private readonly onCancel;
+    private selected;
+    /** Card labels in display order (recommended first, manual last). Read-only
+     *  view for tests that drive the picker without parsing rendered output. */
+    get cardLabels(): string[];
+    /** The question header text. Read-only view for tests. */
+    get headerText(): string;
+    constructor(question: string, cards: BoxCard[], colors: BoxColors, onChoose: (index: number) => void, onCancel: () => void);
+    render(width: number): string[];
+    invalidate(): void;
+    handleInput(data: string): void;
+}
+export interface BoxOption {
+    label: string;
+    value: string;
+    recommended?: boolean;
+}
+export interface AskQuestionBoxSpec {
+    /** Display question for the box header (may carry ANSI). */
+    question: string;
+    /** Plain title for the free-text fallback input dialog. */
+    inputTitle: string;
+    options: BoxOption[];
+    signal: AbortSignal;
+}
+/**
+ * Show the boxed picker and resolve to the chosen option's `value`, the text the
+ * user typed via "type a different answer", or undefined when cancelled/aborted.
+ */
+export declare function askQuestionBox(ctx: ExtensionCommandContext, spec: AskQuestionBoxSpec): Promise<string | undefined>;
+export {};

package/dist/task/question-box.js

@@ -0,0 +1,166 @@
+/**
+ * Boxed question dialog for the clarify / grill phases.
+ *
+ * The built-in `ctx.ui.select` renders every option as a bare line under one
+ * outer frame — the question, the recommendation, and the choices all read as a
+ * single blob. The remote (browser) prompt card instead gives each response its
+ * own bounded panel, tints the recommended one green, and separates everything
+ * with margins. This module mirrors that remote style in the terminal: a custom
+ * `ctx.ui.custom` component that draws each answer in its own bounding box with a
+ * green RECOMMENDED tag, an accent-highlighted cursor box, and clear vertical
+ * spacing.
+ *
+ * `renderQuestionBox` is the pure layout — width in, lines out — so the visual
+ * structure (borders, tag, cursor arrow, padding) is unit-testable without a
+ * live TUI. The component and `askQuestionBox` wire it to keyboard input and the
+ * "type a different answer" free-text fallback.
+ */
+import { getKeybindings, visibleWidth, wrapTextWithAnsi } from '@earendil-works/pi-tui';
+// ─── Constants ───────────────────────────────────────────────────────────────
+/** Left gutter: two columns reserved for the "▸ " cursor so boxes stay aligned. */
+const GUTTER = 2;
+const RECOMMENDED_TAG = 'RECOMMENDED';
+/** Smallest box that still fits "┌─ RECOMMENDED ─┐". Below this we drop the tag. */
+const TAG_MIN_BOX_WIDTH = visibleWidth(`┌─ ${RECOMMENDED_TAG} ─┐`);
+export const QUESTION_LABEL = 'QUESTION';
+export const HINT_TEXT = '↑↓ navigate · enter select · esc cancel';
+export const MANUAL_CARD_LABEL = '✎ Type a different answer…';
+// ─── Pure renderer ─────────────────────────────────────────────────────────────
+function padTo(line, width) {
+    const pad = width - visibleWidth(line);
+    return pad > 0 ? line + ' '.repeat(pad) : line;
+}
+function renderCard(card, selected, boxWidth, c) {
+    const borderFn = selected ? c.borderSelected
+        : card.recommended ? c.borderRecommended
+            : c.border;
+    const innerWidth = Math.max(1, boxWidth - 4); // "│ " + content + " │"
+    const dash = (n) => '─'.repeat(Math.max(0, n));
+    // Top border, with a RECOMMENDED tag woven in when it fits.
+    let top;
+    if (card.recommended && boxWidth >= TAG_MIN_BOX_WIDTH) {
+        // TAG_MIN_BOX_WIDTH is the width at one trailing dash, so add it back.
+        const dashes = boxWidth - TAG_MIN_BOX_WIDTH + 1;
+        top = borderFn('┌─ ') + c.recommendedTag(RECOMMENDED_TAG) + borderFn(` ${dash(dashes)}┐`);
+    }
+    else {
+        top = borderFn(`┌${dash(boxWidth - 2)}┐`);
+    }
+    const bodyLines = wrapTextWithAnsi(card.label, innerWidth);
+    const body = (bodyLines.length > 0 ? bodyLines : ['']).map(line => borderFn('│ ') + padTo(line, innerWidth) + borderFn(' │'));
+    const bottom = borderFn(`└${dash(boxWidth - 2)}┘`);
+    const arrow = selected ? c.arrow('▸') + ' ' : '  ';
+    const pad = '  ';
+    return [arrow + top, ...body.map(b => pad + b), pad + bottom];
+}
+/**
+ * Lay the whole dialog out for `width` columns: a QUESTION label + wrapped
+ * question, one bounding box per card (recommended tinted green, the cursor box
+ * highlighted with an accent border and "▸" arrow), and a key-hint footer.
+ */
+export function renderQuestionBox(width, question, cards, selected, c, hintText = HINT_TEXT) {
+    const W = Math.max(width, 12);
+    const boxWidth = Math.max(6, W - GUTTER);
+    const out = [''];
+    out.push('  ' + c.questionLabel(QUESTION_LABEL));
+    for (const line of wrapTextWithAnsi(question, W - GUTTER))
+        out.push('  ' + line);
+    out.push('');
+    for (let i = 0; i < cards.length; i++) {
+        out.push(...renderCard(cards[i], i === selected, boxWidth, c));
+        out.push('');
+    }
+    for (const line of wrapTextWithAnsi(hintText, W - GUTTER))
+        out.push('  ' + c.hint(line));
+    out.push('');
+    return out;
+}
+// ─── Theme adapter ─────────────────────────────────────────────────────────────
+export function boxColors(theme) {
+    return {
+        border: s => theme.fg('borderMuted', s),
+        borderRecommended: s => theme.fg('success', s),
+        borderSelected: s => theme.fg('accent', s),
+        recommendedTag: s => theme.fg('success', theme.bold(s)),
+        questionLabel: s => theme.fg('accent', theme.bold(s)),
+        hint: s => theme.fg('muted', s),
+        arrow: s => theme.fg('accent', theme.bold(s))
+    };
+}
+// ─── Component ─────────────────────────────────────────────────────────────────
+/** Focusable picker component; navigation mirrors the built-in select dialog. */
+export class QuestionBoxComponent {
+    question;
+    cards;
+    colors;
+    onChoose;
+    onCancel;
+    selected = 0;
+    /** Card labels in display order (recommended first, manual last). Read-only
+     *  view for tests that drive the picker without parsing rendered output. */
+    get cardLabels() {
+        return this.cards.map(c => c.label);
+    }
+    /** The question header text. Read-only view for tests. */
+    get headerText() {
+        return this.question;
+    }
+    constructor(question, cards, colors, onChoose, onCancel) {
+        this.question = question;
+        this.cards = cards;
+        this.colors = colors;
+        this.onChoose = onChoose;
+        this.onCancel = onCancel;
+    }
+    render(width) {
+        return renderQuestionBox(width, this.question, this.cards, this.selected, this.colors);
+    }
+    invalidate() { }
+    handleInput(data) {
+        const kb = getKeybindings();
+        if (kb.matches(data, 'tui.select.up') || data === 'k') {
+            this.selected = Math.max(0, this.selected - 1);
+        }
+        else if (kb.matches(data, 'tui.select.down') || data === 'j') {
+            this.selected = Math.min(this.cards.length - 1, this.selected + 1);
+        }
+        else if (kb.matches(data, 'tui.select.confirm') || data === '\n' || data === '\r') {
+            this.onChoose(this.selected);
+        }
+        else if (kb.matches(data, 'tui.select.cancel')) {
+            this.onCancel();
+        }
+    }
+}
+/**
+ * Show the boxed picker and resolve to the chosen option's `value`, the text the
+ * user typed via "type a different answer", or undefined when cancelled/aborted.
+ */
+export async function askQuestionBox(ctx, spec) {
+    const { question, options, inputTitle, signal } = spec;
+    const cards = [
+        ...options.map(o => ({ label: o.label, recommended: o.recommended })),
+        { label: MANUAL_CARD_LABEL }
+    ];
+    const colors = boxColors(ctx.ui.theme);
+    const manualIndex = options.length;
+    const choice = await ctx.ui.custom((_tui, _theme, _kb, done) => {
+        if (signal.aborted) {
+            done(undefined);
+            return new QuestionBoxComponent(question, cards, colors, () => { }, () => { });
+        }
+        const onAbort = () => done(undefined);
+        signal.addEventListener('abort', onAbort, { once: true });
+        const finish = (result) => {
+            signal.removeEventListener('abort', onAbort);
+            done(result);
+        };
+        return new QuestionBoxComponent(question, cards, colors, index => finish(index), () => finish(undefined));
+    });
+    if (choice === undefined)
+        return undefined;
+    if (choice === manualIndex) {
+        return ctx.ui.input(inputTitle, undefined, { signal });
+    }
+    return options[choice]?.value;
+}

package/dist/task/verify-work.d.ts

@@ -0,0 +1,68 @@
+/**
+ * The verification child gets exactly two tools: `read` and `bash`.
+ *
+ *  - `bash` IS the point: it lets the child actually execute the spec's VERIFY
+ *    commands (or whatever check the ACCEPTANCE criteria imply) and see the real
+ *    exit codes and output, rather than reasoning about whether the code "looks"
+ *    correct.
+ *  - `read` lets it inspect a file the VERIFY output points at (a build error's
+ *    source line, a config it just validated) to characterise a failure precisely.
+ *  - No `edit`/`write`: this pass reports a verdict, it does not change the tree.
+ *    Keeping it read-only means a verify run can never itself introduce a change
+ *    that needs re-verifying, and never scaffolds the junk-file runaway that the
+ *    enforce pass had to drop `write` to stop.
+ */
+declare const VERIFY_TOOLS = "read,bash";
+export interface VerifyOutcome {
+    /** true → the work verified (or verification disabled / nothing to verify).
+     *  false → the child reported the work does NOT satisfy its spec, or the pass
+     *  could not run / produced no verdict. */
+    ok: boolean;
+    /** Short, human-readable reason. Always set when ok === false; on the pass
+     *  path set to the no-op cause ('disabled', 'no spec to verify'). */
+    reason?: string;
+}
+/**
+ * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
+ * task file body. The composed spec lives under a `## spec` header and runs until
+ * the next top-level `## ` section (`## phase timings`). Returns null when no spec
+ * section is present (e.g. a task that never reached compose), which the caller
+ * treats as a pass — there is nothing to verify against.
+ */
+export declare function extractSpecForVerification(taskBody: string): string | null;
+/**
+ * Build the verification child's prompt. Kept pure so the wording is unit-tested
+ * without spawning pi. The contract: run the spec's own verification in the real
+ * workspace, judge against ACCEPTANCE, and end on exactly one verdict line.
+ */
+export declare function buildVerifyPrompt(spec: string): string;
+/**
+ * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL` marker
+ * (the model discusses before concluding, and bash output may echo the word
+ * "VERIFY", so a distinct token and last-match win matter).
+ *
+ * No marker at all is NOT a pass: a verification that cannot state a verdict is a
+ * gray area, and the contract is that unverified work is reported as such.
+ */
+export declare function parseVerifyVerdict(text: string): {
+    pass: boolean;
+    detail: string;
+};
+export interface VerificationDeps {
+    cwd: string;
+    signal?: AbortSignal;
+    /** The composed spec (GOAL/ACCEPTANCE/VERIFY) of the task just committed. When
+     *  null/empty the pass is a no-op (ok: true). */
+    spec: string | null;
+    /** Runs the verification child and returns its assistant text. Injected so
+     *  the orchestrator wires the real child runner and tests use a fake. */
+    runChild: (tools: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+}
+/**
+ * Run the verification pass for one task. A missing spec is a pass. Otherwise run
+ * the child against the real workspace and turn its verdict into an ok/blocked
+ * outcome. Never throws (except a user cancel, which propagates so the loop's
+ * USER_CANCELLED handler reports a clean "cancelled — resume").
+ */
+export declare function runWorkVerification(deps: VerificationDeps): Promise<VerifyOutcome>;
+export { VERIFY_TOOLS };

package/dist/task/verify-work.js

@@ -0,0 +1,161 @@
+/**
+ * Work verification for /task-auto.
+ *
+ * The root failure this addresses: pi-task never *runs* any verification. Each
+ * task's composed spec carries a VERIFY block (and ACCEPTANCE criteria), but that
+ * block is only authored and presence-checked — never executed. The task is then
+ * marked `completed` at handoff. So a task whose implementation does not actually
+ * work (a SPA that won't build, a route wired to a dead stub, a CI file nobody
+ * runs) is indistinguishable from one that does.
+ *
+ * This pass closes that gap WITHOUT assuming any particular shape of project. It
+ * does NOT hardcode `build`, an HTTP probe, a server boot, or a test command —
+ * many tasks have none of those. Instead it hands the just-committed spec (GOAL /
+ * ACCEPTANCE / VERIFY) to a fresh child of the SAME local model, gives it a `read`
+ * and a `bash` tool in the real workspace, and lets the model do its job: run the
+ * verification the spec already declares, observe the REAL output, and report a
+ * PASS / FAIL verdict. If the spec's VERIFY is legitimately a no-op (config-only
+ * change, re-read of a file), the model says so and that is a PASS.
+ *
+ * It runs as a GATE right after the implementation turn, BEFORE the task is
+ * checked off or committed. A FAIL stops the /task-auto run exactly like an
+ * implementation failure: the task is left unchecked and uncommitted so
+ * /task-auto-resume re-runs it, rather than blessing work that does not run.
+ *
+ * Tools: `read` + `bash` only. No `edit`/`write` — verification observes, it does
+ * not fix (fixing committed work is the enforcement pass's job, and a verify pass
+ * that also edits would blur "did it work" with "make it work"). `bash` is what
+ * makes this real: it is the difference between reading the VERIFY block and
+ * RUNNING it.
+ *
+ * Gated by the `verifyWork` config flag. With the flag off, or with no spec to
+ * verify, this is a pass (ok: true).
+ */
+import { USER_CANCELLED } from './child-runner.js';
+/**
+ * The verification child gets exactly two tools: `read` and `bash`.
+ *
+ *  - `bash` IS the point: it lets the child actually execute the spec's VERIFY
+ *    commands (or whatever check the ACCEPTANCE criteria imply) and see the real
+ *    exit codes and output, rather than reasoning about whether the code "looks"
+ *    correct.
+ *  - `read` lets it inspect a file the VERIFY output points at (a build error's
+ *    source line, a config it just validated) to characterise a failure precisely.
+ *  - No `edit`/`write`: this pass reports a verdict, it does not change the tree.
+ *    Keeping it read-only means a verify run can never itself introduce a change
+ *    that needs re-verifying, and never scaffolds the junk-file runaway that the
+ *    enforce pass had to drop `write` to stop.
+ */
+const VERIFY_TOOLS = 'read,bash';
+/**
+ * Slice the delivered spec (GOAL / CONSTRAINTS / ACCEPTANCE / VERIFY) out of a
+ * task file body. The composed spec lives under a `## spec` header and runs until
+ * the next top-level `## ` section (`## phase timings`). Returns null when no spec
+ * section is present (e.g. a task that never reached compose), which the caller
+ * treats as a pass — there is nothing to verify against.
+ */
+export function extractSpecForVerification(taskBody) {
+    const lines = taskBody.split('\n');
+    let start = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^##\s+spec\s*$/i.test(lines[i])) {
+            start = i + 1;
+            break;
+        }
+    }
+    if (start === -1)
+        return null;
+    let end = lines.length;
+    for (let i = start; i < lines.length; i++) {
+        if (/^##\s+\S/.test(lines[i])) {
+            end = i;
+            break;
+        }
+    }
+    const spec = lines.slice(start, end).join('\n').trim();
+    return spec.length > 0 ? spec : null;
+}
+/**
+ * Build the verification child's prompt. Kept pure so the wording is unit-tested
+ * without spawning pi. The contract: run the spec's own verification in the real
+ * workspace, judge against ACCEPTANCE, and end on exactly one verdict line.
+ */
+export function buildVerifyPrompt(spec) {
+    return [
+        'You are a strict verification pass running right after an AI coding agent',
+        'finished a task and committed it. The agent is known to mark work "done"',
+        'without ever running it, so DO NOT trust that the implementation works —',
+        'prove it by running the verification this task ships with.',
+        '',
+        'You have a `read` tool and a `bash` tool — nothing else. You can run any',
+        'command and read any file, but you CANNOT edit or create files. Your job is',
+        'to VERIFY, not to fix.',
+        '',
+        'THE TASK SPEC (its ACCEPTANCE criteria and VERIFY block are the contract):',
+        spec.trim(),
+        '',
+        'How to verify:',
+        "1. Run the commands in the spec's VERIFY block, in order, with your `bash`",
+        '   tool, from the repository root. Observe the REAL exit codes and output —',
+        '   do not assume success.',
+        '2. Treat the ACCEPTANCE criteria as the bar. If a VERIFY command fails, or',
+        '   its output contradicts an ACCEPTANCE criterion, the work has NOT verified.',
+        '3. If a VERIFY command depends on something this environment genuinely lacks',
+        '   (a service, a network resource) and that is clearly an environment gap',
+        '   rather than a defect in the code, note it and judge the rest. Do not fail',
+        '   the task for a missing external service it cannot control.',
+        '4. If the spec legitimately has no runnable verification (a config-only or',
+        '   docs-only change whose VERIFY just re-reads or validates a file), running',
+        '   that re-read/validation cleanly is a PASS.',
+        '5. Do NOT edit anything to make a check pass. Report what you actually saw.',
+        '',
+        'When you are done, output EXACTLY ONE of these as the final line:',
+        '  WORK-VERIFIED: PASS              (every check ran and the work meets its spec)',
+        '  WORK-VERIFIED: FAIL <text>      (a check failed or the work does not meet its spec; say what failed)',
+        'Output the verdict line verbatim — it is parsed mechanically.'
+    ].join('\n');
+}
+/**
+ * Parse the child's verdict. Scans for the LAST `WORK-VERIFIED: PASS|FAIL` marker
+ * (the model discusses before concluding, and bash output may echo the word
+ * "VERIFY", so a distinct token and last-match win matter).
+ *
+ * No marker at all is NOT a pass: a verification that cannot state a verdict is a
+ * gray area, and the contract is that unverified work is reported as such.
+ */
+export function parseVerifyVerdict(text) {
+    const re = /WORK-VERIFIED:\s*(PASS|FAIL)\b[ \t]*(.*)/gi;
+    let last = null;
+    for (let m = re.exec(text); m !== null; m = re.exec(text))
+        last = m;
+    if (!last)
+        return { pass: false, detail: 'no verdict emitted' };
+    const pass = last[1].toUpperCase() === 'PASS';
+    return { pass, detail: pass ? '' : last[2].trim() || 'unspecified failure' };
+}
+/**
+ * Run the verification pass for one task. A missing spec is a pass. Otherwise run
+ * the child against the real workspace and turn its verdict into an ok/blocked
+ * outcome. Never throws (except a user cancel, which propagates so the loop's
+ * USER_CANCELLED handler reports a clean "cancelled — resume").
+ */
+export async function runWorkVerification(deps) {
+    if (!deps.spec || deps.spec.trim().length === 0) {
+        return { ok: true, reason: 'no spec to verify' };
+    }
+    let text;
+    try {
+        text = await deps.runChild(VERIFY_TOOLS, buildVerifyPrompt(deps.spec), deps.signal);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message === USER_CANCELLED)
+            throw err;
+        const msg = err instanceof Error ? err.message : String(err);
+        return { ok: false, reason: `verification pass could not run: ${msg}` };
+    }
+    const verdict = parseVerifyVerdict(text);
+    if (verdict.pass)
+        return { ok: true };
+    return { ok: false, reason: `work did not verify: ${verdict.detail}` };
+}
+export { VERIFY_TOOLS };

package/dist/task/widget.d.ts

@@ -51,8 +51,9 @@ export interface AutoLoaderState {
     contextUsage?: ContextSnapshot;
     /** Which /task-auto stage this loader is for. Defaults to 'planning' (the
      *  numbered clarify/decompose steps); 'enforce' is the per-task guideline
-     *  pass, which has no step numbering. */
-    kind?: 'planning' | 'enforce';
+     *  pass and 'verify' is the per-task work-verification pass, neither of which
+     *  has step numbering. */
+    kind?: 'planning' | 'enforce' | 'verify';
 }
 export declare function buildAutoLoaderLines(s: AutoLoaderState, theme?: WidgetTheme): string[];
 /**

package/dist/task/widget.js

@@ -121,9 +121,9 @@ export function startWidget(ctx, getState) {
 export function buildAutoLoaderLines(s, theme) {
     const elapsed = formatDuration(Date.now() - s.startedAt);
     const head = `/task-auto · ${s.title}`;
-    let detail = s.kind === 'enforce' ?
-        `enforcing guidelines · ${elapsed}`
-        : `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
+    let detail = s.kind === 'enforce' ? `enforcing guidelines · ${elapsed}`
+        : s.kind === 'verify' ? `verifying work · ${elapsed}`
+            : `planning ${s.stepNum}/${s.stepTotal} ${s.step} · ${elapsed}`;
     if (s.contextUsage) {
         const ctxDetail = formatContextDetail(s.contextUsage, theme);
         if (ctxDetail)

package/package.json

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