@mjasnikovs/pi-task 0.13.7 → 0.13.8

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/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,38 @@ 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);
+        // 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)}`
+            : shownQ;
         const a = await ui.ask({
             localTitle: title,
             question: plainQ,
             recommended: plainSuggested,
-            allowSkip: plainSuggested === undefined
+            ...(plainAlt !== undefined && { recommended2: plainAlt }),
+            allowSkip: plainSuggested === undefined && plainAlt === undefined
         });
         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;
         let answer;
         if (typed.length === 0 && plainSuggested) {
             answer = `${plainSuggested} (accepted recommendation)`;
@@ -96,6 +112,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 +252,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/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.8",
     "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",