@mjasnikovs/pi-task 0.13.8 → 0.13.9

package/dist/remote/bridge.d.ts

@@ -28,6 +28,19 @@ export interface AskSpec {
     recommended2?: string;
     /** Whether the browser card shows a Skip button (answers with empty string). */
     allowSkip: boolean;
+    /**
+     * When set, the local TUI shows a select() picker of these entries instead of
+     * a bare text input — one option per line, arrow-key navigable. Each entry's
+     * `label` is what the picker displays; its `value` is what ask() resolves to
+     * when chosen. A built-in "type a different answer" entry is appended that
+     * falls back to a text input, preserving the free-text override. Used for the
+     * binary A/B grill/clarify fork. Remote browsers ignore this and keep
+     * rendering recommended/recommended2 as buttons.
+     */
+    options?: {
+        label: string;
+        value: string;
+    }[];
 }
 /** Wraps a live command ctx and fans interactions out to local TUI + browsers. */
 export declare class SessionUI {
@@ -38,6 +51,15 @@ export declare class SessionUI {
     get hasUI(): boolean;
     /** 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.
+     */
+    private askLocal;
 }
 export declare function publishNotify(message: string, level: 'info' | 'warning' | 'error'): void;
 export declare function publishViewer(title: string, text: string): void;

package/dist/remote/bridge.js

@@ -25,6 +25,9 @@ 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;
@@ -63,9 +66,7 @@ export class SessionUI {
         // Local: resolves to a value/undefined, or undefined on abort. Swallow
         // the rejection some implementations throw on abort so it never leaks.
         const local = this.ctx.hasUI ?
-            this.ctx.ui
-                .input(spec.localTitle, spec.recommended, { signal: ac.signal })
-                .catch(() => undefined)
+            this.askLocal(spec, ac.signal).catch(() => undefined)
             : new Promise(() => { });
         try {
             const winner = await Promise.race([
@@ -81,6 +82,31 @@ export class SessionUI {
             clearPrompt(id);
         }
     }
+    /**
+     * 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.
+     */
+    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], {
+                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 });
+    }
 }
 export function publishNotify(message, level) {
     getBridge().broadcast({ type: 'notify', message, level });

package/dist/task/auto-orchestrator.js

@@ -80,31 +80,39 @@ export async function planAuto(ctx, cwd, feature, deps) {
         const plainQ = stripInlineMarkdown(question);
         const plainSuggested = suggested === undefined ? undefined : stripInlineMarkdown(suggested);
         const plainAlt = alt === undefined ? undefined : stripInlineMarkdown(alt);
-        // Compact A/B presentation, identical to /task's grill dialog: a binary
-        // fork shows both options labelled A/B; a single recommendation shows just
-        // the default; an open question shows the bare prompt. No verbose
-        // "Recommended:" / "press Enter to accept" scaffolding.
-        const title = plainSuggested ?
-            plainAlt ?
-                `${shownQ}\nA: ${renderInlineMarkdown(suggested, theme)}\nB: ${renderInlineMarkdown(alt, theme)}`
-                : `${shownQ}\n${renderInlineMarkdown(suggested, theme)}`
+        // 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.
+        const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+        const title = !twoOption && plainSuggested ?
+            `${shownQ}\n${renderInlineMarkdown(suggested, theme)}`
             : shownQ;
         const a = await ui.ask({
             localTitle: title,
             question: plainQ,
             recommended: plainSuggested,
             ...(plainAlt !== undefined && { recommended2: plainAlt }),
-            allowSkip: plainSuggested === undefined && plainAlt === undefined
+            allowSkip: plainSuggested === undefined && plainAlt === undefined,
+            ...(twoOption && {
+                options: [
+                    {
+                        label: `A: ${renderInlineMarkdown(suggested, theme)}`,
+                        value: plainSuggested
+                    },
+                    { label: `B: ${renderInlineMarkdown(alt, theme)}`, value: plainAlt }
+                ]
+            })
         });
         if (a === undefined) {
             ctx.ui.notify('/task-auto cancelled.', 'warning');
             return null;
         }
         const typed = a.trim();
-        // Two-option mode labels the choices "A:"/"B:", so a user (local TUI or
-        // remote "Manual answer") naturally types the bare letter to pick. Map it
-        // back to the option's full text. Mirrors phaseGrill's answer mapping.
-        const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+        // The local picker resolves to the chosen option's full value, but a
+        // remote user (or the picker's free-text fallback) may still type a bare
+        // "A"/"B" — map those back to the option's full text. Mirrors phaseGrill.
         let answer;
         if (typed.length === 0 && plainSuggested) {
             answer = `${plainSuggested} (accepted recommendation)`;

package/dist/task/phases.js

@@ -326,10 +326,13 @@ 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);
-            const localTitle = plainSuggested ?
-                plainAlt ?
-                    `${shownQ}\nA: ${renderInlineMarkdown(auto.suggested, theme)}\nB: ${renderInlineMarkdown(auto.alt, theme)}`
-                    : `${shownQ}\n${renderInlineMarkdown(auto.suggested, theme)}`
+            // 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.
+            const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+            const localTitle = !twoOption && plainSuggested ?
+                `${shownQ}\n${renderInlineMarkdown(auto.suggested, theme)}`
                 : shownQ;
             widgetState.lastLine = `awaiting Q${n + 1}`;
             const a = await ui.ask({
@@ -337,16 +340,25 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
                 question: plainQ,
                 recommended: plainSuggested,
                 recommended2: plainAlt,
-                allowSkip: plainSuggested === undefined && plainAlt === undefined
+                allowSkip: plainSuggested === undefined && plainAlt === undefined,
+                ...(twoOption && {
+                    options: [
+                        {
+                            label: `A: ${renderInlineMarkdown(auto.suggested, theme)}`,
+                            value: plainSuggested
+                        },
+                        { label: `B: ${renderInlineMarkdown(auto.alt, theme)}`, value: plainAlt }
+                    ]
+                })
             });
             if (a === undefined)
                 throw new Error(USER_CANCELLED);
             const typed = a.trim();
-            // Two-option mode labels the choices "A:"/"B:", so a user (local TUI
-            // or remote "Manual answer") naturally types the bare letter to pick.
-            // Map it back to the option's full text — storing the literal "A"
-            // leaves the next grill-gen call a dangling reference it can't decode.
-            const twoOption = plainSuggested !== undefined && plainAlt !== undefined;
+            // The local picker resolves to the chosen option's full value, but a
+            // remote user (or the picker's free-text fallback) may still type a
+            // bare "A"/"B" — map those back to the option's full text, since
+            // storing the literal letter leaves the next grill-gen call a
+            // dangling reference it can't decode.
             if (typed.length === 0 && plainSuggested) {
                 answer = plainSuggested;
             }

package/package.json

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