@mjasnikovs/pi-task 0.13.12 → 0.13.14

package/dist/remote/events.js

@@ -1,5 +1,4 @@
 import { setAgentIdle } from './state.js';
-import { pushNotify } from './push.js';
 import { publishNotify } from './bridge.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
@@ -22,10 +21,11 @@ export function setupEvents(pi) {
             if (errorMessage || ae.reason === 'error') {
                 const message = errorMessage || 'Request failed';
                 addError(message);
-                // 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(() => { });
+                // No push here: pi-task only notifies for the two cases the user
+                // cares about — needing their input (the grill/clarify dialog, see
+                // bridge.ask) and a top-level /task or /task-auto run finishing
+                // (orchestrator/auto-orchestrator). A push on every host agent
+                // error — most of them outside any task — is just noise.
             }
         }
     });
@@ -44,7 +44,12 @@ export function setupEvents(pi) {
     pi.on('agent_end', (_event, ctx) => {
         setAgentIdle(true);
         agentEnd(ctx.getContextUsage());
-        void pushNotify('Task finished', '', 'pi-end').catch(() => { });
+        // Deliberately no push: agent_end fires on EVERY host turn — every chat
+        // reply, every internal phase turn inside /task, and every internal /task
+        // run inside /task-auto — so a "Task finished" push here floods the device.
+        // The real "a run finished" push is fired from the top-level command
+        // handlers instead (orchestrator handleTask/handleTaskResume, and
+        // auto-orchestrator's runAutoLoop), which never fire for internal runs.
     });
     pi.on('input', (event, _ctx) => {
         if (event.source === 'interactive' && typeof event.text === 'string') {

package/dist/task/auto-orchestrator.js

@@ -16,6 +16,7 @@ import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath } from
 import { gitCommitAll } from './auto-commit.js';
 import { runPhaseChild, USER_CANCELLED } from './child-runner.js';
 import { SessionUI, registerBridgeCommand } from '../remote/bridge.js';
+import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
 import { startAutoLoader } from './widget.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
@@ -106,7 +107,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
             })
         });
         if (a === undefined) {
-            ctx.ui.notify('/task-auto cancelled.', 'warning');
+            announceDone(ctx, '/task-auto cancelled.', 'warning');
             return null;
         }
         const typed = a.trim();
@@ -139,7 +140,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
     const listRaw = await deps.runChild('auto-decompose', 'read', AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications));
     const titles = parseDecomposeList(listRaw);
     if (titles.length === 0) {
-        ctx.ui.notify('/task-auto: no tasks produced from the feature.', 'warning');
+        announceDone(ctx, '/task-auto: no tasks produced from the feature.', 'warning');
         return null;
     }
     // persist
@@ -220,6 +221,17 @@ let autoRunning = false;
 export function requestAutoCancel() {
     cancelRequested = true;
 }
+/**
+ * Announce a terminal /task-auto-overall outcome both in the terminal and to
+ * subscribed devices. The push body reuses the exact terminal message, so a
+ * backgrounded phone learns the same thing the TUI shows. Used ONLY at the
+ * overall run's terminal points — never per internal task (those go through
+ * runSingleTask without notifyFinish, so they stay silent).
+ */
+function announceDone(ctx, msg, level) {
+    ctx.ui.notify(msg, level);
+    void pushNotify('Task finished', msg, 'pi-end').catch(() => { });
+}
 export async function runAutoLoop(ctx, cwd, id, deps) {
     cancelRequested = false;
     // Each task runs in its own fresh session (deps.runTask → ctx.newSession),
@@ -230,7 +242,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
     try {
         for (;;) {
             if (cancelRequested) {
-                active.ui.notify(`${id} cancelled — resume with /task-auto-resume.`, 'warning');
+                announceDone(active, `${id} cancelled — resume with /task-auto-resume.`, 'warning');
                 return;
             }
             const { body } = await readTaskFile(cwd, id);
@@ -238,7 +250,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             const next = entries.find(e => !e.done);
             if (!next) {
                 await updateTaskFrontMatter(cwd, id, { state: 'completed' });
-                active.ui.notify(`${id} complete — all ${entries.length} tasks done.`, 'info');
+                announceDone(active, `${id} complete — all ${entries.length} tasks done.`, 'info');
                 return;
             }
             active.ui.notify(`${id}: task ${next.index + 1}/${entries.length} — ${next.title}`, 'info');
@@ -277,7 +289,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             });
             active = res.ctx ?? active;
             if (res.sessionCancelled) {
-                active.ui.notify(`${id} paused — could not start a session. Run /task-auto-resume to retry.`, 'warning');
+                announceDone(active, `${id} paused — could not start a session. Run /task-auto-resume to retry.`, 'warning');
                 return;
             }
             if (res.interrupted) {
@@ -287,12 +299,12 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 // this task's spec to finish it. (A plain ESC that the user
                 // follows with steering text never reaches here — that loops on
                 // the same task inside runSingleTask until a turn completes.)
-                active.ui.notify(`${id} paused at "${next.title}" — resume with /task-auto-resume.`, 'warning');
+                announceDone(active, `${id} paused at "${next.title}" — resume with /task-auto-resume.`, 'warning');
                 return;
             }
             if (!res.ok) {
                 await updateTaskFrontMatter(cwd, id, { state: 'failed' });
-                active.ui.notify(`${id} stopped at "${next.title}" — fix and run /task-auto-resume.`, 'error');
+                announceDone(active, `${id} stopped at "${next.title}" — fix and run /task-auto-resume.`, 'error');
                 return;
             }
             // res.ok === true means runner.run() completed, so res.taskId is the
@@ -319,11 +331,11 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
         // 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');
+            announceDone(active, `${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');
+        announceDone(active, `${id} stopped: ${msg} — fix and run /task-auto-resume.`, 'error');
     }
     finally {
         cancelRequested = false;
@@ -350,10 +362,10 @@ async function handleTaskAuto(args, ctx) {
         autoRunning = false;
         const msg = err instanceof Error ? err.message : String(err);
         if (msg === USER_CANCELLED) {
-            ctx.ui.notify('/task-auto cancelled.', 'warning');
+            announceDone(ctx, '/task-auto cancelled.', 'warning');
             return;
         }
-        ctx.ui.notify(`/task-auto planning failed: ${msg}`, 'error');
+        announceDone(ctx, `/task-auto planning failed: ${msg}`, 'error');
         return;
     }
     if (!id) {
@@ -365,7 +377,7 @@ async function handleTaskAuto(args, ctx) {
     if (cancelRequested) {
         cancelRequested = false;
         autoRunning = false;
-        ctx.ui.notify('/task-auto cancelled.', 'warning');
+        announceDone(ctx, '/task-auto cancelled.', 'warning');
         return;
     }
     await runAutoLoop(ctx, cwd, id, deps);

package/dist/task/auto-prompts.js

@@ -34,18 +34,33 @@ 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 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. 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.
+YOU MUST propose a default answer for the question — every question you emit
+carries exactly one SUGGESTED line. Never omit it, never leave it blank, never
+refuse. Infer the most sensible, concrete, decisive default from the repo, the
+referenced docs, and any stated philosophy or constraints; it is shown to the
+user as a recommendation they accept or override. When the question is a genuine
+binary "A or B?" fork, also give the single best alternative as an ALT line;
+otherwise emit only the one SUGGESTED.
 
 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>".
+- On the NEXT line (never inline), a line that begins with "SUGGESTED: <your recommended default>". This line is REQUIRED for every question.
 - 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:
+- Only when the spec already pins down every choice that would change the task breakdown — nothing decision-changing is left to ask — output exactly the single token NONE on its own line (and no SUGGESTED line).
+
+EXAMPLES (format only — your wording will differ):
+
+Open-ended question:
+1. **Where should uploaded files be stored?** This forks whether an early storage-abstraction task is needed.
+SUGGESTED: store on local disk under ./uploads, served by the existing static handler
+
+Binary "A or B?" fork:
+1. **Should the Zod schemas live in a shared module imported by both server and client, or stay server-only with manual client types?** This decides whether a "shared schema" task must land before any route or API-client work.
+SUGGESTED: a shared schema module imported by both, so \`hc()\` gets typed RPC for free
+ALT: server-only schemas with hand-written client types
+
+No question remains:
 NONE`;
 /**
  * Decompose: output a markdown checkbox list of task titles (one line each).

package/dist/task/orchestrator.d.ts

@@ -77,6 +77,13 @@ export interface RunSingleTaskOptions {
      * steer loop is testable without a real dialog.
      */
     promptSteer?: (ctx: ExtensionCommandContext) => Promise<string | undefined>;
+    /**
+     * Push a "Task finished" notification to subscribed devices when this run
+     * reaches a terminal state (completed / failed / cancelled). Set only by the
+     * top-level /task and /task-resume command handlers — NOT by /task-auto's
+     * internal per-task runs, which must stay silent. Default false.
+     */
+    notifyFinish?: boolean;
 }
 export interface RunSingleTaskResult {
     taskId: string;

package/dist/task/orchestrator.js

@@ -24,6 +24,7 @@ import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parser
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
+import { pushNotify } from '../remote/push.js';
 import { parseVerifyBlock } from './spec-validation.js';
 import { formatTimings } from './timings.js';
 import { getParentContextWindow, resolveContextUsage } from './context-usage.js';
@@ -342,18 +343,29 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     });
     if (result.cancelled) {
         // No replacement happened — the original ctx is still live.
+        if (opts.notifyFinish) {
+            void pushNotify('Task finished', `${taskId || 'Task'} cancelled — could not start a session.`, 'pi-end').catch(() => { });
+        }
         return { taskId, ok: false, sessionCancelled: true, ctx };
     }
     let ok = false;
+    let state;
     if (taskId) {
         try {
             const { frontMatter } = await readTaskFile(cwd, taskId);
-            ok = frontMatter.state === 'completed';
+            state = frontMatter.state;
+            ok = state === 'completed';
         }
         catch {
             ok = false;
         }
     }
+    if (opts.notifyFinish) {
+        // One push per top-level /task or /task-resume, on any terminal end. The
+        // file state is the source of truth: 'completed' on success, 'failed' /
+        // 'cancelled' otherwise; an unreadable/absent file falls back to 'ended'.
+        void pushNotify('Task finished', `${taskId || 'Task'} ${state ?? 'ended'}.`, 'pi-end').catch(() => { });
+    }
     return { taskId, ok, sessionCancelled: false, ctx: freshCtx, interrupted };
 }
 // ─── Command handlers ────────────────────────────────────────────────────────
@@ -366,7 +378,7 @@ async function handleTask(args, ctx) {
         ctx.ui.notify('Type your prompt after /task (use @ for file completion).', 'info');
         return;
     }
-    const { sessionCancelled } = await runSingleTask(ctx, cwd, raw);
+    const { sessionCancelled } = await runSingleTask(ctx, cwd, raw, { notifyFinish: true });
     if (sessionCancelled) {
         ctx.ui.notify('Could not start a fresh session for /task.', 'warning');
     }
@@ -449,7 +461,7 @@ async function handleTaskResume(args, ctx) {
         }
         id = candidates[0].id;
     }
-    const { sessionCancelled } = await runSingleTask(ctx, cwd, '', { resumeId: id });
+    const { sessionCancelled } = await runSingleTask(ctx, cwd, '', { resumeId: id, notifyFinish: true });
     if (sessionCancelled) {
         ctx.ui.notify('Could not start a fresh session for /task-resume.', 'warning');
     }

package/package.json

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