@mjasnikovs/pi-task 0.13.7 → 0.13.9

package/dist/config/register.js

@@ -11,7 +11,7 @@ const ITEMS = [
     {
         id: 'autoCommit',
         label: 'auto-commit',
-        description: 'git commit after each /task-auto sub-task'
+        description: 'git commit around each /task-auto sub-task (checkpoint before, snapshot after)'
     }
 ];
 function makeTheme(theme) {

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/remote/register.js

@@ -5,7 +5,7 @@ import { reset, addUserTurn } from './session-state.js';
 import { html } from './ui.js';
 import { qrLines } from './qr.js';
 import { startServer, formatAddresses } from './server.js';
-import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls } from './tailscale.js';
+import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls, hostFromResult } from './tailscale.js';
 import { isAgentIdle } from './state.js';
 const _g = globalThis;
 if (!_g.__piRemote)
@@ -105,10 +105,14 @@ export function registerRemote(pi) {
                 const server = await ensureServer();
                 const httpPrimary = `http://${server.ip}:${server.port}`;
                 const result = S.serveResult ?? { state: 'unavailable' };
-                const plan = planRemoteUrls(httpPrimary, result);
+                const plan = planRemoteUrls(httpPrimary, result, server.port);
                 const primaryUrl = plan.primaryUrl;
                 const qr = await qrLines(primaryUrl);
-                const addrs = [...plan.urlLines, ...formatAddresses(server.ips, server.port)];
+                const tsHost = hostFromResult(result);
+                const addrs = [
+                    ...plan.urlLines,
+                    ...formatAddresses(server.ips, server.port, tsHost)
+                ];
                 const labelW = addrs.reduce((m, a) => Math.max(m, a.label.length), 0);
                 const addrLines = [
                     ...addrs.map(a => (a.label ? `${a.label.padEnd(labelW)}  ${a.url}` : a.url)),

package/dist/remote/server.d.ts

@@ -24,7 +24,9 @@ export interface ServerHandle {
 type MessageCallback = (text: string) => void;
 export declare function getLocalIPs(nets?: NodeJS.Dict<import("node:os").NetworkInterfaceInfo[]>): LocalIPs;
 /** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
- *  when present; a single unlabeled primary URL when neither resolves. */
-export declare function formatAddresses(ips: LocalIPs, port: number): AddressLine[];
+ *  when present; a single unlabeled primary URL when neither resolves. The
+ *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
+ *  but is what SSH and webpush certs need), falling back to the raw IP. */
+export declare function formatAddresses(ips: LocalIPs, port: number, tsHost?: string): AddressLine[];
 export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string): Promise<ServerHandle>;
 export {};

package/dist/remote/server.js

@@ -33,10 +33,14 @@ export function getLocalIPs(nets = networkInterfaces()) {
     return { tailscale, lan, primary: tailscale ?? lan ?? '127.0.0.1' };
 }
 /** Build the labeled URL lines shown under the QR code. Both Tailscale and LAN
- *  when present; a single unlabeled primary URL when neither resolves. */
-export function formatAddresses(ips, port) {
+ *  when present; a single unlabeled primary URL when neither resolves. The
+ *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
+ *  but is what SSH and webpush certs need), falling back to the raw IP. */
+export function formatAddresses(ips, port, tsHost) {
     const out = [];
-    if (ips.tailscale)
+    if (tsHost)
+        out.push({ label: 'Tailscale', url: `http://${tsHost}:${port}` });
+    else if (ips.tailscale)
         out.push({ label: 'Tailscale', url: `http://${ips.tailscale}:${port}` });
     if (ips.lan)
         out.push({ label: 'LAN', url: `http://${ips.lan}:${port}` });

package/dist/remote/tailscale.d.ts

@@ -9,6 +9,7 @@ export interface Run {
 export type ServeResult = {
     state: 'served';
     url: string;
+    host: string;
 } | {
     state: 'foreign-conflict';
     host: string;
@@ -18,6 +19,8 @@ export type ServeResult = {
 } | {
     state: 'unavailable';
 };
+/** The MagicDNS host of a serve result, or undefined when the daemon had no name. */
+export declare function hostFromResult(result: ServeResult): string | undefined;
 export interface RemoteUrlPlan {
     /** URL to encode in the QR and announce; the https one when serve is live. */
     primaryUrl: string;
@@ -41,5 +44,8 @@ export declare function ensureTailscaleServe(port: number, run?: Run): Promise<S
  *  Best-effort; callers should additionally `.catch()` since it may run during
  *  shutdown. */
 export declare function teardownTailscaleServe(port: number, run?: Run): Promise<void>;
-/** Pure: pick the primary URL and any hint lines from a serve result. */
-export declare function planRemoteUrls(httpPrimary: string, result: ServeResult): RemoteUrlPlan;
+/** Pure: pick the primary URL (what the QR encodes) and any hint lines from a
+ *  serve result. Prefers the MagicDNS host over the raw IP whenever it's known —
+ *  the https URL when serve is live, else http://<host>:<port> — so the QR and
+ *  the announced URL carry the tailnet name (needed for SSH and webpush certs). */
+export declare function planRemoteUrls(httpPrimary: string, result: ServeResult, port: number): RemoteUrlPlan;

package/dist/remote/tailscale.js

@@ -1,4 +1,8 @@
 import { execFile } from 'node:child_process';
+/** The MagicDNS host of a serve result, or undefined when the daemon had no name. */
+export function hostFromResult(result) {
+    return result.state === 'unavailable' ? undefined : result.host;
+}
 const defaultRun = (cmd, args) => new Promise(resolve => {
     execFile(cmd, args, { timeout: 5000 }, (err, stdout, stderr) => {
         const exitCode = err && typeof err.code === 'number' ?
@@ -54,7 +58,7 @@ export async function ensureTailscaleServe(port, run = defaultRun) {
     const serve = await run('tailscale', ['serve', 'status', '--json']);
     const target = serve443Target(serve.stdout);
     if (target === ours)
-        return { state: 'served', url: `https://${host}` };
+        return { state: 'served', url: `https://${host}`, host };
     if (target !== undefined)
         return { state: 'foreign-conflict', host };
     // No :443 handler yet — check cert capability before trying to create one.
@@ -64,7 +68,7 @@ export async function ensureTailscaleServe(port, run = defaultRun) {
     }
     const set = await run('tailscale', ['serve', '--bg', '--https=443', ours]);
     if (set.exitCode === 0)
-        return { state: 'served', url: `https://${host}` };
+        return { state: 'served', url: `https://${host}`, host };
     return { state: 'certs-disabled', host };
 }
 /** Tear down the :443 serve handler ONLY if it currently points at our port.
@@ -76,8 +80,11 @@ export async function teardownTailscaleServe(port, run = defaultRun) {
         await run('tailscale', ['serve', '--https=443', 'off']);
     }
 }
-/** Pure: pick the primary URL and any hint lines from a serve result. */
-export function planRemoteUrls(httpPrimary, result) {
+/** Pure: pick the primary URL (what the QR encodes) and any hint lines from a
+ *  serve result. Prefers the MagicDNS host over the raw IP whenever it's known —
+ *  the https URL when serve is live, else http://<host>:<port> — so the QR and
+ *  the announced URL carry the tailnet name (needed for SSH and webpush certs). */
+export function planRemoteUrls(httpPrimary, result, port) {
     switch (result.state) {
         case 'served':
             return {
@@ -87,7 +94,7 @@ export function planRemoteUrls(httpPrimary, result) {
             };
         case 'foreign-conflict':
             return {
-                primaryUrl: httpPrimary,
+                primaryUrl: `http://${result.host}:${port}`,
                 urlLines: [],
                 hintLines: [
                     'HTTPS: port 443 is already used by another tailscale serve config; not touching it.',
@@ -96,7 +103,7 @@ export function planRemoteUrls(httpPrimary, result) {
             };
         case 'certs-disabled':
             return {
-                primaryUrl: httpPrimary,
+                primaryUrl: `http://${result.host}:${port}`,
                 urlLines: [],
                 hintLines: [
                     'HTTPS (for phone notifications): enable HTTPS in the Tailscale admin console, then restart the remote.'

package/dist/task/auto-orchestrator.js

@@ -55,8 +55,12 @@ 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.
+    // exactly like /task's grill dialog: a binary fork offers two options (A/B),
+    // otherwise the model's recommendation is shown as the input placeholder and
+    // in the title. Nothing is pre-filled into the editor — submitting an empty
+    // field is what accepts the recommendation (see the typed.length === 0 branch
+    // below); typing overrides it. We never auto-answer; the model emits NONE when
+    // nothing remains.
     const theme = ctx.ui.theme;
     const ui = new SessionUI(ctx);
     // Inline any @file spec the user referenced so clarify/decompose reason over
@@ -69,26 +73,46 @@ export async function planAuto(ctx, cwd, feature, deps) {
         const parsed = parseClarifyList(qRaw);
         if (parsed.length === 0)
             break; // NONE / nothing left to ask
-        const { question, suggested } = parsed[0];
+        const { question, suggested, alt } = 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 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.
+        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,
-            allowSkip: plainSuggested === undefined
+            ...(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 }
+                ]
+            })
         });
         if (a === undefined) {
             ctx.ui.notify('/task-auto cancelled.', 'warning');
             return null;
         }
         const typed = a.trim();
+        // 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)`;
@@ -96,6 +120,12 @@ export async function planAuto(ctx, cwd, feature, deps) {
         else if (typed.length === 0) {
             answer = '(skipped)';
         }
+        else if (twoOption && /^a[.)]?$/i.test(typed)) {
+            answer = plainSuggested;
+        }
+        else if (twoOption && /^b[.)]?$/i.test(typed)) {
+            answer = plainAlt;
+        }
         else {
             answer = typed;
         }
@@ -230,6 +260,17 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                     resumeId = undefined;
                 }
             }
+            // Before starting, fold any uncommitted work into its own checkpoint
+            // commit so a dirty tree at the start of the run — or edits left behind
+            // by an interrupted/failed task — land separately instead of being swept
+            // into this task's snapshot. Best-effort and a no-op on a clean tree
+            // (gitCommitAll commits nothing), so it only ever produces a commit when
+            // there is stray work; the matching post-task commit below is the "after"
+            // half. Only the success path is announced to keep the common no-op quiet.
+            const checkpoint = await deps.commit(cwd, `chore: checkpoint before "${next.title}"`);
+            if (checkpoint.committed) {
+                active.ui.notify(`${id}: checkpointed uncommitted work before "${next.title}".`, 'info');
+            }
             const res = await deps.runTask(active, cwd, next.title, {
                 resumeId,
                 onStart: resumeId ? undefined : (innerId => stampTaskInProgress(cwd, id, next.index, innerId, next.title))

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

@@ -4,9 +4,10 @@
  */
 /**
  * Clarify: asks ONE question at a time. Output MUST match parseClarifyList — a
- * single numbered question followed by a "SUGGESTED: <default>" line, or the
- * literal token NONE when no clarification remains. priorQA carries the
- * questions already answered so each next question adapts to them.
+ * single numbered question followed by a "SUGGESTED: <default>" line, an optional
+ * "ALT: <alternative>" line for binary "A or B?" forks, or the literal token NONE
+ * when no clarification remains. priorQA carries the questions already answered so
+ * each next question adapts to them.
  */
 export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string) => string;
 /**

package/dist/task/auto-prompts.js

@@ -4,9 +4,10 @@
  */
 /**
  * Clarify: asks ONE question at a time. Output MUST match parseClarifyList — a
- * single numbered question followed by a "SUGGESTED: <default>" line, or the
- * literal token NONE when no clarification remains. priorQA carries the
- * questions already answered so each next question adapts to them.
+ * single numbered question followed by a "SUGGESTED: <default>" line, an optional
+ * "ALT: <alternative>" line for binary "A or B?" forks, or the literal token NONE
+ * when no clarification remains. priorQA carries the questions already answered so
+ * each next question adapts to them.
  */
 export const AUTO_CLARIFY_PROMPT = (feature, priorQA) => `You are planning how to split a feature into separate implementation tasks, one clarifying question at a time.
 
@@ -33,14 +34,16 @@ fork the breakdown). Account for the answers so far:
   real-time vs polling transport, search, deployment).
 - Skip anything /task will naturally resolve per-task during its own research.
 
-Also propose the single most sensible default answer for this question, inferred
-from the repo, the referenced docs, and any stated philosophy or constraints —
+Also propose the most sensible default answer for this question, inferred from
+the repo, the referenced docs, and any stated philosophy or constraints —
 concrete and decisive, shown to the user as a recommendation they can accept or
-override.
+override. When the question is a genuine binary "A or B?" fork, also give the
+single best alternative as a second option; otherwise offer only the one default.
 
 OUTPUT FORMAT (exact):
 - One clarifying question as a single numbered line: "1. ...".
 - On the NEXT line (never inline), a line that begins with "SUGGESTED: <your recommended default>".
+- ONLY for a binary "A or B?" fork, on the line after that, a line beginning with "ALT: <the alternative option>". Omit the ALT line entirely for open-ended questions.
 - Put the core question in **bold**, followed by a short one-line rationale in plain prose. Backticks around code/identifiers are fine. Avoid other markdown (headings, bullet lists, links).
 - Only when the spec already pins down every choice that would change the task breakdown — nothing decision-changing is left to ask — output exactly:
 NONE`;

package/dist/task/parsers.d.ts

@@ -17,9 +17,12 @@ export type AutoAnswer = {
 export interface ClarifyQuestion {
     question: string;
     suggested?: string;
+    /** Secondary option for a binary "A or B?" fork; mirrors grill's ALT line. */
+    alt?: string;
 }
 export declare const GRILL_LINE_RE: RegExp;
 export declare const SUGGESTED_LINE_RE: RegExp;
+export declare const ALT_LINE_RE: RegExp;
 export declare function parseGrillQuestions(raw: string): string[];
 export declare function parseClarifyList(raw: string): ClarifyQuestion[];
 export declare function autoAnswerHasTag(raw: string): boolean;

package/dist/task/parsers.js

@@ -7,6 +7,7 @@ import { MAX_GRILL_QUESTIONS } from './phases.js';
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const GRILL_LINE_RE = /^\s*\d+[.)]\s+(.+)$/;
 export const SUGGESTED_LINE_RE = /^\s*SUGGESTED:\s*(.*)$/i;
+export const ALT_LINE_RE = /^\s*ALT:\s*(.*)$/i;
 // ─── Grill questions parser ──────────────────────────────────────────────────
 // The grill-gen prompt instructs the worker to emit the literal token `NONE`
 // when it has zero questions, so the runner's empty-output guard can still
@@ -30,14 +31,32 @@ export function parseGrillQuestions(raw) {
 // (e.g. "1. ...so this must be resolved. SUGGESTED: use polling.") rather than
 // on its own line.
 const INLINE_SUGGESTED_RE = /\bSUGGESTED:\s*/i;
-/** Split a question line's text into the question and any inline SUGGESTED default. */
+const INLINE_ALT_RE = /\bALT:\s*/i;
+/**
+ * Split a question line's text into the question, any inline SUGGESTED default,
+ * and any inline ALT secondary option (the model may write both on one line:
+ * "1. A or B? SUGGESTED: A ALT: B").
+ */
 function splitInlineSuggested(text) {
     const m = INLINE_SUGGESTED_RE.exec(text);
     if (!m)
         return { question: text.trim() };
     const question = text.slice(0, m.index).trim();
-    const suggested = text.slice(m.index + m[0].length).trim();
-    return suggested.length > 0 ? { question, suggested } : { question };
+    let rest = text.slice(m.index + m[0].length);
+    let alt;
+    const altM = INLINE_ALT_RE.exec(rest);
+    if (altM) {
+        const altText = rest.slice(altM.index + altM[0].length).trim();
+        if (altText.length > 0)
+            alt = altText;
+        rest = rest.slice(0, altM.index);
+    }
+    const suggested = rest.trim();
+    return {
+        question,
+        ...(suggested.length > 0 && { suggested }),
+        ...(alt !== undefined && { alt })
+    };
 }
 // Parses the /task-auto clarify output: a numbered question list where each
 // question carries a "SUGGESTED: <default>" recommendation — either on its own
@@ -67,6 +86,15 @@ export function parseClarifyList(raw) {
             if (suggested.length > 0 && last.suggested === undefined) {
                 last.suggested = suggested;
             }
+            continue;
+        }
+        const altLine = ALT_LINE_RE.exec(line);
+        if (altLine && out.length > 0) {
+            const alt = altLine[1].trim();
+            const last = out[out.length - 1];
+            if (alt.length > 0 && last.alt === undefined) {
+                last.alt = alt;
+            }
         }
     }
     return out;

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/dist/workers/html-clean.js

@@ -11,21 +11,22 @@ const turndown = new TurndownService({
 });
 export function cleanHtml(html, baseUrl) {
     const { document } = parseHTML(html);
+    const doc = document;
     const reader = new Readability(document);
     const parsed = reader.parse();
     if (parsed && parsed.content) {
         return {
-            title: parsed.title || document.title || new URL(baseUrl).hostname,
+            title: parsed.title || doc.title || new URL(baseUrl).hostname,
             markdown: turndown.turndown(parsed.content).trim(),
             finalUrl: baseUrl
         };
     }
     // Fallback: turndown the body
-    const body = document.body;
+    const body = doc.body;
     const bodyHtml = body ? body.innerHTML : '';
     const markdown = turndown.turndown(bodyHtml).trim();
     return {
-        title: document.title || new URL(baseUrl).hostname,
+        title: doc.title || new URL(baseUrl).hostname,
         markdown,
         finalUrl: baseUrl
     };
@@ -147,7 +148,9 @@ export async function fetchAndClean(url, opts = {}) {
         let bytesRead = 0;
         try {
             while (true) {
-                const { value, done } = await reader.read();
+                // response.body's stream type doesn't resolve here, so the chunk
+                // surfaces as `any`; pin it to the Uint8Array the reader yields.
+                const { value, done } = (await reader.read());
                 if (done)
                     break;
                 if (value) {

package/package.json

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