@mjasnikovs/pi-task 0.13.4 → 0.13.6

package/dist/remote/bridge.js

@@ -1,4 +1,4 @@
-import { broadcast as wsBroadcast, hasConnectedClients } from './broadcast.js';
+import { broadcast as wsBroadcast } from './broadcast.js';
 import { pushNotify } from './push.js';
 import { setPrompt, clearPrompt } from './session-state.js';
 const g = globalThis;
@@ -56,9 +56,10 @@ export class SessionUI {
             allowSkip: spec.allowSkip
         };
         setPrompt(prompt);
-        // Reaches a backgrounded/suspended phone, which the in-page UI can't.
-        if (!hasConnectedClients())
-            void pushNotify('pi needs your input', spec.question, 'pi-prompt').catch(() => { });
+        // Reaches a backgrounded/suspended phone, which the in-page UI can't. The
+        // service worker drops the banner if a window is visible+focused (sw.ts),
+        // so we always push and let delivery-time visibility decide.
+        void pushNotify('pi needs your input', spec.question, 'pi-prompt').catch(() => { });
         // 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 ?

package/dist/remote/broadcast.d.ts

@@ -3,4 +3,3 @@ export declare function addClient(ws: WebSocket): void;
 export declare function removeClient(ws: WebSocket): void;
 export declare function broadcast(msg: unknown): void;
 export declare function sendTo(ws: WebSocket, msg: unknown): void;
-export declare function hasConnectedClients(): boolean;

package/dist/remote/broadcast.js

@@ -22,10 +22,3 @@ export function sendTo(ws, msg) {
         ws.send(JSON.stringify(msg));
     }
 }
-export function hasConnectedClients() {
-    for (const ws of clients) {
-        if (ws.readyState === ws.OPEN)
-            return true;
-    }
-    return false;
-}

package/dist/remote/events.js

@@ -1,7 +1,6 @@
 import { setAgentIdle } from './state.js';
 import { pushNotify } from './push.js';
 import { publishNotify } from './bridge.js';
-import { hasConnectedClients } from './broadcast.js';
 import { agentStart, appendText, textEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
 /** Mirror pi agent events into the authoritative SessionState. Each handler
  *  drives a mutator, which updates the snapshot AND broadcasts the live delta. */
@@ -23,8 +22,10 @@ export function setupEvents(pi) {
             if (errorMessage || ae.reason === 'error') {
                 const message = errorMessage || 'Request failed';
                 addError(message);
-                if (!hasConnectedClients())
-                    void pushNotify('Agent error', message, 'pi-error').catch(() => { });
+                // Always push; the service worker suppresses the banner when a
+                // window is actually visible+focused (sw.ts), which is the only
+                // reliable foreground signal — an open WebSocket is not one.
+                void pushNotify('Agent error', message, 'pi-error').catch(() => { });
             }
         }
     });
@@ -43,8 +44,7 @@ export function setupEvents(pi) {
     pi.on('agent_end', (_event, ctx) => {
         setAgentIdle(true);
         agentEnd(ctx.getContextUsage());
-        if (!hasConnectedClients())
-            void pushNotify('Task finished', '', 'pi-end').catch(() => { });
+        void pushNotify('Task finished', '', 'pi-end').catch(() => { });
     });
     pi.on('input', (event, _ctx) => {
         if (event.source === 'interactive' && typeof event.text === 'string') {

package/dist/remote/server.js

@@ -121,21 +121,6 @@ export async function startServer(onMessage, getHtml) {
         handle.onFirstConnect = null;
         // One authoritative snapshot — the client replaces its whole view with it.
         sendTo(ws, snapshot());
-        // Heartbeat: ping every 30 s; terminate if the client doesn't respond.
-        // This catches phones that close/sleep without sending a TCP FIN, so the
-        // server's client-set stays accurate and push notifications fire correctly.
-        let alive = true;
-        const heartbeat = setInterval(() => {
-            if (!alive) {
-                ws.terminate();
-                return;
-            }
-            alive = false;
-            ws.ping();
-        }, 10_000);
-        ws.on('pong', () => {
-            alive = true;
-        });
         ws.on('message', data => {
             let msg;
             try {
@@ -157,7 +142,6 @@ export async function startServer(onMessage, getHtml) {
             onMessage(msg.text);
         });
         ws.on('close', () => {
-            clearInterval(heartbeat);
             removeClient(ws);
         });
     });

package/dist/remote/ui.js

@@ -202,6 +202,10 @@ export function html(wsUrl) {
       font-family: inherit; line-height: 1.5; resize: vertical; margin-bottom: 4px; }
     #prompt-card .row { display: flex; gap: 8px; margin-top: 12px; align-items: stretch;
       flex-wrap: wrap; }
+    /* Recommendation answers can be long sentences, so stack them as a readable list. */
+    #prompt-card .row.stacked { flex-direction: column; align-items: stretch; }
+    #prompt-card .row.stacked button { flex: none; text-align: left; }
+    #prompt-card .row.stacked button.cancel { align-self: center; text-align: center; }
     #prompt-card button { padding: 11px 16px; border-radius: 8px; border: none; cursor: pointer;
       font-family: inherit; font-size: 14px; font-weight: 600; transition: filter .15s ease; }
     #prompt-card button:hover { filter: brightness(1.08); }
@@ -772,7 +776,8 @@ export function html(wsUrl) {
       return btn;
     }
 
-    function renderButtons(buttons) {
+    function renderButtons(buttons, stacked) {
+      promptButtons.className = stacked ? 'row stacked' : 'row';
       promptButtons.innerHTML = '';
       for (let i = 0; i < buttons.length; i++) promptButtons.appendChild(buttons[i]);
       promptButtons.appendChild(makeCancelBtn());
@@ -800,11 +805,14 @@ export function html(wsUrl) {
         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(); }));
+        // Answer buttons hold full sentences — stack them so long text stays readable.
+        renderButtons(buttons, true);
+        return;
       }
+      // 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);
     }

package/dist/task/auto-orchestrator.js

@@ -12,7 +12,7 @@ import { parseClarifyList, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
-import { writeTaskFile, readTaskFile, updateTaskFrontMatter } from './task-io.js';
+import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath } from './task-io.js';
 import { gitCommitAll } from './auto-commit.js';
 import { runPhaseChild, USER_CANCELLED } from './child-runner.js';
 import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
@@ -217,12 +217,25 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             active.ui.notify(`${id}: task ${next.index + 1}/${entries.length} — ${next.title}`, 'info');
             // If this entry already has a stamped inner id, it was started in a
             // previous (interrupted) run — resume it from its saved phase rather
-            // than spawning a fresh task. Otherwise stamp the freshly-allocated id
-            // onto the entry the moment it exists, so an interruption here is
-            // resumable too. This mirrors /task-resume's continue-don't-restart.
+            // than spawning a fresh task. But the stamped inner file can be gone
+            // (deleted, or never written because allocation was interrupted), and
+            // resuming a missing file throws ENOENT deep in the runner — which used
+            // to take pi down. So verify the file exists and otherwise fall back to
+            // a fresh start. Either way an unstamped/restarted entry is (re)stamped
+            // the moment its inner id exists, keeping the next interruption
+            // resumable. This mirrors /task-resume's continue-don't-restart.
+            let resumeId = next.producedId;
+            if (resumeId) {
+                try {
+                    await fsp.access(taskFilePath(cwd, resumeId));
+                }
+                catch {
+                    resumeId = undefined;
+                }
+            }
             const res = await deps.runTask(active, cwd, next.title, {
-                resumeId: next.producedId,
-                onStart: next.producedId ? undefined : (innerId => stampTaskInProgress(cwd, id, next.index, innerId, next.title))
+                resumeId,
+                onStart: resumeId ? undefined : (innerId => stampTaskInProgress(cwd, id, next.index, innerId, next.title))
             });
             active = res.ctx ?? active;
             if (res.sessionCancelled) {
@@ -251,6 +264,19 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             }
         }
     }
+    catch (err) {
+        // Safety net: no failure inside the loop may propagate out of runAutoLoop,
+        // because the resume handler doesn't wrap this call and an unhandled
+        // rejection crashes pi outright. Convert it into a failed run + notify,
+        // mirroring the in-loop per-task failure path.
+        const msg = err instanceof Error ? err.message : String(err);
+        if (msg === USER_CANCELLED) {
+            active.ui.notify(`${id} cancelled — resume with /task-auto-resume.`, 'warning');
+            return;
+        }
+        await updateTaskFrontMatter(cwd, id, { state: 'failed' }).catch(() => { });
+        active.ui.notify(`${id} stopped: ${msg} — fix and run /task-auto-resume.`, 'error');
+    }
     finally {
         cancelRequested = false;
     }

package/dist/task/parsers.js

@@ -233,7 +233,6 @@ export function validateSpecShape(spec) {
 // ─── Title derivation ────────────────────────────────────────────────────────
 export function deriveTitle(refined) {
     const stripBold = (s) => s.replace(/^\*+|\*+$/g, '').trim();
-    const truncate = (s) => (s.length > 119 ? s.slice(0, 119) + '…' : s);
     const lines = refined.split('\n');
     for (let i = 0; i < lines.length; i++) {
         const stripped = stripBold(lines[i].trim().replace(/^#+\s+/, ''));
@@ -245,7 +244,7 @@ export function deriveTitle(refined) {
                 const headerCheck = stripBold(line.replace(/^#+\s+/, ''));
                 if (/^(CONSTRAINTS|KNOWN-UNKNOWNS)\s*:?\s*$/i.test(headerCheck))
                     break;
-                return truncate(line);
+                return line;
             }
             break;
         }
@@ -257,7 +256,7 @@ export function deriveTitle(refined) {
         line = stripBold(line.replace(/^#+\s+/, '')).replace(/^GOAL\s*:?\s*/i, '');
         if (line.length === 0)
             continue;
-        return truncate(line);
+        return line;
     }
     return '(untitled)';
 }

package/dist/task/phases.js

@@ -397,12 +397,23 @@ export async function phaseGrill(deps, ctx, widgetState, refined, research) {
             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;
             if (typed.length === 0 && plainSuggested) {
                 answer = plainSuggested;
             }
             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;
             }

package/package.json

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