@mjasnikovs/pi-task 0.13.2 → 0.13.3

package/dist/remote/bridge.d.ts

@@ -22,8 +22,10 @@ export interface AskSpec {
     localTitle: string;
     /** Plain question text for the browser card. */
     question: string;
-    /** Plain recommended default (prefilled in both surfaces), if any. */
+    /** Primary recommended option, prefilled in the local TUI. */
     recommended?: string;
+    /** Secondary recommended option shown as a second button on the remote. */
+    recommended2?: string;
     /** Whether the browser card shows a Skip button (answers with empty string). */
     allowSkip: boolean;
 }

package/dist/remote/bridge.js

@@ -52,6 +52,7 @@ export class SessionUI {
             id,
             question: spec.question,
             recommended: spec.recommended,
+            ...(spec.recommended2 !== undefined && { recommended2: spec.recommended2 }),
             allowSkip: spec.allowSkip
         };
         setPrompt(prompt);

package/dist/remote/protocol.d.ts

@@ -3,6 +3,7 @@ export interface PromptMessage {
     id: string;
     question: string;
     recommended?: string;
+    recommended2?: string;
     allowSkip: boolean;
 }
 export interface PromptResolvedMessage {

package/dist/remote/ui.js

@@ -297,6 +297,7 @@ export function html(wsUrl) {
     document.getElementById('viewer-close').onclick = function () { viewer.style.display = 'none'; };
     let activePromptId = null;
     let activeRecommended = '';
+    let activeRecommended2 = '';
     let cancelArmTimer = null;
     const toolCallMap = {};
     let currentBubble = null;
@@ -737,6 +738,7 @@ export function html(wsUrl) {
       promptInput.value = '';
       promptInput.style.display = 'none';
       promptRec.style.display = 'none';
+      activeRecommended2 = '';
       if (cancelArmTimer) { clearTimeout(cancelArmTimer); cancelArmTimer = null; }
       setEnabled(true);
     }
@@ -776,36 +778,44 @@ export function html(wsUrl) {
       promptButtons.appendChild(makeCancelBtn());
     }
 
-    // Manual-entry view: editable textarea + Submit, reachable from the
-    // recommendation view via "Answer manually".
-    function showManualEntry(prefill) {
+    // Manual-entry view: empty textarea + Submit, reachable from the
+    // recommendation view via "Manual answer".
+    function showManualEntry() {
       promptRec.style.display = 'none';
       promptInput.style.display = 'block';
-      promptInput.value = prefill || '';
+      promptInput.value = '';
       renderButtons([
-        makeBtn('Submit answer', 'primary', function () { answer(promptInput.value); }),
+        makeBtn('Submit', 'primary', function () { answer(promptInput.value); }),
         makeBtn('← Back', 'secondary', function () { showRecommendation(); })
       ]);
       promptInput.focus();
     }
 
-    // Recommendation view (Mode A): show the suggested answer and let the user
-    // accept it in one tap or switch to manual entry.
+    // Recommendation view: 2-button mode when both options present, panel mode for one.
     function showRecommendation() {
       promptInput.style.display = 'none';
-      promptRec.style.display = 'block';
-      renderButtons([
-        makeBtn('✓ Accept recommended', 'primary', function () { answer(''); }),
-        makeBtn('✎ Answer manually', 'secondary', function () { showManualEntry(activeRecommended); })
-      ]);
+      const buttons = [];
+      if (activeRecommended2) {
+        // Two-option mode: each recommendation is a direct-accept button.
+        promptRec.style.display = 'none';
+        buttons.push(makeBtn(activeRecommended, 'primary', function () { answer(activeRecommended); }));
+        buttons.push(makeBtn(activeRecommended2, 'secondary', function () { answer(activeRecommended2); }));
+      } else {
+        // Single recommendation: show it in the green panel.
+        promptRec.style.display = 'block';
+        buttons.push(makeBtn('✓ Accept', 'primary', function () { answer(activeRecommended); }));
+      }
+      buttons.push(makeBtn('✎ Manual answer', 'secondary', function () { showManualEntry(); }));
+      renderButtons(buttons);
     }
 
     function showPrompt(msg) {
       activePromptId = msg.id;
       promptQ.textContent = msg.question;
       activeRecommended = msg.recommended || '';
+      activeRecommended2 = msg.recommended2 || '';
       if (msg.recommended) {
-        // Mode A: there's a recommendation — lead with "Accept recommended".
+        // Mode A: recommendation(s) present.
         promptRecText.textContent = msg.recommended;
         showRecommendation();
       } else {
@@ -813,9 +823,9 @@ export function html(wsUrl) {
         promptRec.style.display = 'none';
         promptInput.style.display = 'block';
         promptInput.value = '';
-        const buttons = [makeBtn('Submit answer', 'primary', function () { answer(promptInput.value); })];
+        const buttons = [makeBtn('Submit', 'primary', function () { answer(promptInput.value); })];
         if (msg.allowSkip) {
-          buttons.push(makeBtn('Skip question', 'secondary', function () { answer(''); }));
+          buttons.push(makeBtn('Skip', 'secondary', function () { answer(''); }));
         }
         renderButtons(buttons);
         promptInput.focus();

package/dist/shared/child-process.js

@@ -199,9 +199,9 @@ export function summarizeToolArgs(toolName, args) {
     if (toolName === 'bash' && typeof a.command === 'string') {
         return a.command.replace(/\s+/g, ' ').trim();
     }
-    if (toolName === 'pi-worker-docs' &&
-        typeof a.module === 'string' &&
-        typeof a.query === 'string') {
+    if (toolName === 'pi-worker-docs'
+        && typeof a.module === 'string'
+        && typeof a.query === 'string') {
         const q = a.query.replace(/\s+/g, ' ').trim();
         const truncated = q.length > 60 ? q.slice(0, 59) + '…' : q;
         return `${a.module} "${truncated}"`;

package/dist/task/orchestrator.js

@@ -168,7 +168,9 @@ export class TaskRunner {
         const debugLogPath = path.join(tasksDir(cwd), `${id}-debug.log`);
         this._deps.logDebug = (msg) => {
             const line = `${new Date().toISOString()} ${msg}\n`;
-            fsp.appendFile(debugLogPath, line).catch(() => { });
+            fsp.appendFile(debugLogPath, line).catch(() => {
+                /* ignore */
+            });
         };
         this._deps.logDebug(`run: start phase=${resumePhase}`);
         // Register as active.

package/dist/task/parsers.d.ts

@@ -13,6 +13,7 @@ export type AutoAnswer = {
 } | {
     kind: 'unknown';
     suggested?: string;
+    alt?: string;
     raw: string;
 };
 /** One /task-auto clarify question with its model-recommended default answer. */

package/dist/task/parsers.js

@@ -102,22 +102,44 @@ export function parseAutoAnswer(raw) {
         .split('\n')
         .map(l => l.trim())
         .filter(l => l.length > 0);
+    let suggested;
+    let alt;
+    let sawUnknown = false;
     for (let i = 0; i < lines.length; i++) {
         const t = lines[i];
         const a = /^AN[SW]{1,3}E?R:\s*(.+)$/i.exec(t);
         if (a)
             return { kind: 'answered', text: a[1].trim(), raw };
-        const u = /^UNKNOWN:\s*(.*)$/i.exec(t);
-        if (u) {
-            const inline = u[1].trim();
-            if (inline.length > 0)
-                return { kind: 'unknown', suggested: inline, raw };
-            const next = lines[i + 1];
-            if (next && next.length > 0)
-                return { kind: 'unknown', suggested: next, raw };
-            return { kind: 'unknown', raw };
+        if (!sawUnknown) {
+            const u = /^UNKNOWN:\s*(.*)$/i.exec(t);
+            if (u) {
+                sawUnknown = true;
+                const inline = u[1].trim();
+                if (inline.length > 0) {
+                    suggested = inline;
+                }
+                else {
+                    const next = lines[i + 1];
+                    if (next && !/^ALT:/i.test(next))
+                        suggested = next;
+                }
+                continue;
+            }
+        }
+        if (alt === undefined) {
+            const altM = /^ALT:\s*(.+)$/i.exec(t);
+            if (altM)
+                alt = altM[1].trim();
         }
     }
+    if (sawUnknown || suggested !== undefined || alt !== undefined) {
+        return {
+            kind: 'unknown',
+            ...(suggested !== undefined && { suggested }),
+            ...(alt !== undefined && { alt }),
+            raw
+        };
+    }
     if (lines.length > 0)
         return { kind: 'unknown', suggested: lines[0], raw };
     return { kind: 'unknown', raw };

package/dist/task/phases.js

@@ -373,8 +373,6 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
         const shownQ = renderInlineMarkdown(q, theme);
         const plainQ = stripInlineMarkdown(q);
         out.push(`Q${n + 1}: ${plainQ}`);
-        const rawTrim = auto.raw.trim();
-        out.push(`  (auto-worker raw: ${rawTrim.length === 0 ? '(empty)' : rawTrim.replace(/\n/g, ' ⏎ ')})`);
         let answer;
         if (auto.kind === 'answered') {
             answer = stripInlineMarkdown(auto.text);
@@ -382,21 +380,25 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
         }
         else {
             const plainSuggested = auto.suggested === undefined ? undefined : stripInlineMarkdown(auto.suggested);
-            const localTitle = auto.suggested ?
-                `${shownQ}\n${theme.fg('muted', 'Recommended:')}\n\n${renderInlineMarkdown(auto.suggested, theme)}\n\n${theme.fg('muted', 'press Enter to accept')}`
-                : `${shownQ}\n${theme.fg('muted', '(no recommendation — please answer)')}`;
+            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)}`
+                : shownQ;
             widgetState.lastLine = `awaiting Q${n + 1}`;
             const a = await ui.ask({
                 localTitle,
                 question: plainQ,
                 recommended: plainSuggested,
-                allowSkip: plainSuggested === undefined
+                recommended2: plainAlt,
+                allowSkip: plainSuggested === undefined && plainAlt === undefined
             });
             if (a === undefined)
                 throw new Error(USER_CANCELLED);
             const typed = a.trim();
             if (typed.length === 0 && plainSuggested) {
-                answer = `${plainSuggested} (accepted recommendation)`;
+                answer = plainSuggested;
             }
             else if (typed.length === 0) {
                 answer = '(skipped)';

package/dist/task/prompts.js

@@ -176,57 +176,37 @@ ${research}
 
 Answers so far:
 ${priorQA.trim() || '(none yet)'}`;
-const GRILL_AUTO_ANSWER_PROMPT = (refined, research, question) => `You are pre-answering a clarifying question for an AI coding task. You have the refined task and the research notes. You can also use the read tool to open any file mentioned in the research (e.g. package.json) if it helps you answer.
-
-Your job is to produce a recommended default answer. If the default is one the user would almost certainly accept, you tag it ANSWER and we skip the user entirely. Otherwise you tag it UNKNOWN and we show the suggestion in the input box for the user to confirm or override.
-
-YOU MUST PROPOSE A DEFAULT, no matter what. NEVER refuse. NEVER leave the answer empty.
-
-LIVE-DATA RULE — read carefully:
-- If EXTERNAL CONTEXT contains an "### npm: <pkg>" block, those version numbers are LIVE registry data and are MORE RECENT than anything you remember from training. Use them as the source of truth.
-- For any question about "latest", "current", "newest", or "which version" of an npm package, you MUST cite the version from the "### npm: <pkg>" block in EXTERNAL CONTEXT if one is present. Do NOT contradict it with a remembered version.
-- If EXTERNAL CONTEXT contains a "### service: <name>" block, those search results are LIVE web data and are authoritative over training data for that service's current API surface, deprecation status, and replacement systems. For any question about that service's API, status, or replacement, cite from the block; do not contradict it from memory.
-- If EXTERNAL CONTEXT contains a "### freshness-check skipped" block, you have no current data for the listed services. If the question is about one of them, tag UNKNOWN and say the current state needs user verification — do NOT answer from memory.
-- If no "### npm: <pkg>" block is present and the question is about latest/current versions, tag UNKNOWN — do not invent a version from training data, since that data goes stale within months.
-
-Use the REVERSIBILITY TEST to choose the tag:
-
-  ANSWER: accepting your default is cheap to undo — output style, reporting
-          format, treat-as-error policy, summary vs full output, scope when
-          obviously implied, recommended convention for a typical project.
-          If the user would only "fix" your default by editing prose in the
-          task file, it's ANSWER.
-
-  UNKNOWN: accepting your default would do work that is costly to reverse —
-           file mutations, destructive operations, irreversible writes, tool
-           or dependency choices, format/structure decisions that change
-           downstream artifacts, anything that touches state outside the
-           task file. This INCLUDES choosing the implementation approach,
-           algorithm, or strategy — *how* the task is solved, not just
-           whether (e.g. "extract the value with a post-processing regex" vs
-           "rewrite the system prompt", "add a fallback step" vs "swap the
-           model", "parse manually" vs "use a library"). Approach decisions
-           shape the entire spec and are expensive to unwind once the agent
-           builds on them, so the user must vet the strategy: tag UNKNOWN and
-           surface your recommended approach as the default.
-
-Output format — ONE LINE only, no preamble, no markdown:
+const GRILL_AUTO_ANSWER_PROMPT = (refined, research, question) => `You are pre-answering a clarifying question for an AI coding task. You have the refined task and the research notes. You may use the read tool on files mentioned in the research (e.g. package.json) if it helps.
+
+Your job is to produce a recommended default. If the default is one the user would almost certainly accept without thinking, tag it ANSWER and skip the user. Otherwise tag it UNKNOWN. YOU MUST PROPOSE A DEFAULT — never refuse, never leave it empty.
+
+LIVE-DATA RULE:
+- "### npm: <pkg>" blocks in EXTERNAL CONTEXT are LIVE registry data; use those version numbers, do NOT invent them from memory.
+- "### service: <name>" blocks are LIVE web data; authoritative over training data for that service.
+- "### freshness-check skipped" → tag UNKNOWN and say current state needs verification.
+- No npm block + question is about latest/current version → tag UNKNOWN (training data goes stale).
+
+REVERSIBILITY TEST:
+  ANSWER: cheap to undo (output style, policy, report format, obvious scope, standard convention).
+  UNKNOWN: costly to reverse (file mutations, tool/dependency choice, approach/algorithm, format that shapes downstream artifacts).
+
+When the question is a binary "A or B?" choice, emit BOTH options:
+  UNKNOWN: <primary recommendation>
+  ALT: <alternative>
+
+Output — no preamble, no markdown:
   ANSWER: <one-line answer>
-  UNKNOWN: <one-line default>
+  UNKNOWN: <primary option>
+  ALT: <secondary option>     ← required when question is "A or B?"; omit otherwise
 
 Examples:
-  ANSWER: report a summary with counts and representative examples           ← reporting style is cheap to undo
-  ANSWER: treat all warnings and errors as genuine issues, do not ignore     ← policy is cheap to undo
-  ANSWER: run the read-only check variant (prettier --check, eslint, tsc)    ← read-only side, safer default; flip later if wanted
-  UNKNOWN: use npm                                                           ← package manager choice is costly to reverse mid-task
-  UNKNOWN: write output to ./report.md                                       ← creates a file; user may want a different path or no file
-  UNKNOWN: extract the value with a post-processing regex step               ← picks the implementation approach; user must vet the strategy
-
-Examples of FORBIDDEN outputs:
-  UNKNOWN:
-  UNKNOWN: it depends
-  (empty)
-  I think the user should decide.
+  ANSWER: report a summary with counts and representative examples
+  ANSWER: treat all warnings and errors as genuine issues
+  UNKNOWN: use npm
+  ALT: use pnpm
+  UNKNOWN: write output to ./report.md
+  UNKNOWN: extract with a post-processing regex step
+  ALT: rewrite the system prompt
 
 Refined task:
 ${refined}

package/dist/workers/docs-project.js

@@ -52,8 +52,8 @@ function walkTsFiles(root) {
             const full = path.join(dir, entry.name);
             if (entry.isDirectory())
                 stack.push(full);
-            else if (entry.isFile() &&
-                (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
+            else if (entry.isFile()
+                && (entry.name.endsWith('.ts') || entry.name.endsWith('.tsx'))) {
                 out.push(full);
             }
         }

package/dist/workers/pi-worker-docs.js

@@ -82,7 +82,10 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     return textResult(`Project docs error: ${projectResult.message}`, {});
                 }
                 if (projectResult.kind === 'no_chunks') {
-                    return textResult(`Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`, { hitCache: projectResult.hitCache, indexedFiles: projectResult.filesIngested });
+                    return textResult(`Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`, {
+                        hitCache: projectResult.hitCache,
+                        indexedFiles: projectResult.filesIngested
+                    });
                 }
                 const { projectName, chunks, hitCache, filesIngested, indexingMs } = projectResult;
                 const baseDetails = {
@@ -110,10 +113,14 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     });
                 }
                 const parsed = parseChildOutput(child.stdout);
-                const verified = parsed.excerpt ?
-                    isExcerptInContent(parsed.excerpt, concatenated)
-                    : undefined;
-                const text = formatResultText({ name: projectName, version: 'local', root: ctx.cwd, entryDts: null, readme: null }, parsed, verified);
+                const verified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;
+                const text = formatResultText({
+                    name: projectName,
+                    version: 'local',
+                    root: ctx.cwd,
+                    entryDts: null,
+                    readme: null
+                }, parsed, verified);
                 return textResult(text, {
                     ...baseDetails,
                     childExitCode: 0,

package/package.json

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