@mjasnikovs/pi-task 0.39.1 → 0.39.3

package/dist/task/task-gates.js

@@ -1,6 +1,6 @@
 import { verifyFailClass } from './verify-work.js';
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
-import { SessionUI } from '../remote/bridge.js';
+import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
 import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
 import { attributeEnforceFailure } from './enforce-attribution.js';
@@ -92,7 +92,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
     // accept-override leaves this false → enforce runs flag-only.
     let verifyCleanPass = false;
     if (deps.verify) {
-        active.ui.notify(`${p.tag}: verifying "${p.title}"…`, 'info');
+        notifyBoth(active, `${p.tag}: verifying "${p.title}"…`, 'info');
         let verified = await deps.verify(active, p.cwd, p.title, p.taskId);
         await rec(verdictLine(verified));
         // A FAIL no longer dead-stops. When the research recommends AUTOFIX, pi
@@ -122,7 +122,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             const failClass = verifyFailClass(verified);
             if (!lintFixAttempted && deps.lintFix && failClass === 'repo-health') {
                 lintFixAttempted = true;
-                active.ui.notify(`${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
+                notifyRun(active, `${p.tag}: static findings on "${p.title}" — attempting bounded lint fix…`, 'info');
                 const fix = await deps.lintFix(active, p.cwd, p.title, p.taskId, failReason);
                 await rec(`lint-fix: ${fix.ok ?
                     `applied${fix.reason ? ` (${fix.reason})` : ''} — re-verifying`
@@ -239,7 +239,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                     `resolution: auto-AUTOFIX (${YOLO_STAMP} rescue — judge recommended ACCEPT with the unattended `
                         + `budget unspent; one attempt, ${autoFixCount}/${MAX_AUTO_AUTOFIX})`
                     : `resolution: auto-AUTOFIX (recommended, unattended ${autoFixCount}/${MAX_AUTO_AUTOFIX})`);
-                active.ui.notify(`${p.tag}: verify FAIL on "${p.title}" — auto-fixing (${yoloRescueNow ? `${YOLO_STAMP} one attempt before accepting` : 'recommended'}, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
+                notifyRun(active, `${p.tag}: verify FAIL on "${p.title}" — auto-fixing (${yoloRescueNow ? `${YOLO_STAMP} one attempt before accepting` : 'recommended'}, ${autoFixCount}/${MAX_AUTO_AUTOFIX})…`, 'info');
                 choice = { action: 'autofix' };
             }
             else {
@@ -286,7 +286,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                         // recording must never break the gate sequence
                     }
                 }
-                active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.${byYolo ? ` ${YOLO_STAMP}` : ''}`, 'warning');
+                notifyRun(active, `${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.${byYolo ? ` ${YOLO_STAMP}` : ''}`, 'warning');
                 break;
             }
             // AUTOFIX: re-run the implementation turn with the failure (and any typed
@@ -302,7 +302,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             if (!autoFixNow && !yoloRescueNow) {
                 await rec('resolution: user chose AUTOFIX — re-running the implementation turn');
             }
-            active.ui.notify(`${p.tag}: autofixing "${p.title}"…`, 'info');
+            notifyBoth(active, `${p.tag}: autofixing "${p.title}"…`, 'info');
             const diagnosis = (recOutcome.recommend === 'autofix'
                 && recOutcome.rationale.length > 0
                 && recOutcome.rationale !== failReason) ?
@@ -396,7 +396,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 const reverted = await deps.revertFrozenPaths(p.cwd, frozen);
                 if (reverted.length > 0) {
                     await rec(`enforce: frozen-path write DENIED — reverted ${reverted.length} spec-frozen file(s) the edit pass modified: ${reverted.join(', ')}`);
-                    active.ui.notify(`${p.tag}: guideline edits on "${p.title}" touched spec-frozen path(s) (${reverted.join(', ').slice(0, 120)}) — reverted before commit.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline edits on "${p.title}" touched spec-frozen path(s) (${reverted.join(', ').slice(0, 120)}) — reverted before commit.`, 'warning');
                 }
             }
         }
@@ -408,7 +408,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
         const editsMade = mode === 'edit' && deps.dirty ? await deps.dirty(p.cwd) : undefined;
         await rec(`enforce(${mode}): ${verdict.ok ? `clean${verdict.reason ? ` (${verdict.reason})` : ''}` : (verdict.reason ?? 'not clean')}${editsMade ? ' — edits in tree' : ''}`);
         if (!verdict.ok) {
-            active.ui.notify(`${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
+            notifyRun(active, `${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
         }
         // PRE-COMMIT health gate on enforce edits: an edit pass that breaks the
         // repo's own lint would otherwise burn a commit, a model re-verify and a
@@ -443,7 +443,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 else {
                     await rec(`enforce: edits REGRESSED repo health pre-commit (${after.reason}) — no discard available, left uncommitted${outputTail}`);
                 }
-                active.ui.notify(`${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
+                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
             }
             else if (!after.ok) {
                 // Failing both before and after → not enforce's fault. Keep the edits;
@@ -512,7 +512,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 if (!after.ok && rootCause) {
                     await rec(`enforce: re-verify FAILED (${afterReason.slice(0, 200)}) but the failure is attributed to a PRE-EXISTING defect in \`${rootCause.file}\` `
                         + `(${rootCause.owner}'s file, untouched by the ENFORCE COMMIT whose fate this differential decides) — edits KEPT, not reverted; repair task queued`);
-                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on a pre-existing defect in ${rootCause.file} (${rootCause.owner}'s file) — keeping the fixes, queued a repair task.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes on "${p.title}" re-verified red on a pre-existing defect in ${rootCause.file} (${rootCause.owner}'s file) — keeping the fixes, queued a repair task.`, 'warning');
                 }
                 else if (!after.ok && attribution?.verdict === 'keep') {
                     // KEEP, mechanically justified: every file the failing check named
@@ -547,7 +547,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                             // queueing a repair must never break the gate sequence
                         }
                     }
-                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on ${attribution.file ?? 'a file'} — outside the enforce diff, so keeping the fixes and recording the defect.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes on "${p.title}" re-verified red on ${attribution.file ?? 'a file'} — outside the enforce diff, so keeping the fixes and recording the defect.`, 'warning');
                 }
                 else if (!after.ok) {
                     if (deps.revert)
@@ -567,11 +567,11 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                     // gate re-checks and surfaces it (static-class auto-closes if a
                     // later task fixed the statics; otherwise it stays open).
                     await deps.recordDebt?.(p.cwd, p.taskId, after.reason ?? 'enforce re-verify failed', 'enforce-revert');
-                    active.ui.notify(`${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
+                    notifyRun(active, `${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
                 }
                 else {
                     await rec('enforce: fixes committed — re-verify PASS, kept');
-                    active.ui.notify(`${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
+                    notifyRun(active, `${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
                 }
             }
             else {
@@ -651,7 +651,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 + `${commit.excluded.slice(0, 8).join(', ')}`
                 + `${commit.excluded.length > 8 ? `, +${commit.excluded.length - 8} more` : ''}`);
         }
-        active.ui.notify(`${p.tag}: committed "${p.title}".`, 'info');
+        notifyBoth(active, `${p.tag}: committed "${p.title}".`, 'info');
     }
     else {
         await rec(`commit: skipped (${commit.reason ?? 'unknown'})`);
@@ -661,9 +661,15 @@ export async function runGatesForTask(ctxIn, deps, p) {
         // warnings to show for it. "blocked" is the unmerged-index refusal
         // (gitCommitAll) — the same severity: nothing can commit until it's resolved.
         const gitFailure = /^git (commit|add) (failed|blocked)/.test(commit.reason ?? '');
-        active.ui.notify(gitFailure ?
+        const line = gitFailure ?
             `${p.tag}: COMMIT FAILED (${commit.reason}) — enforce and revert guards are disabled for this task.`
-            : `${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`, gitFailure ? 'error' : 'warning');
+            : `${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`;
+        // A git failure means the whole task ran unguarded. A remote user cannot
+        // infer that from the widget, and a toast is gone before they look.
+        if (gitFailure)
+            notifyRun(active, line, 'error');
+        else
+            notifyBoth(active, line, 'warning');
     }
     await runEnforcePass(active, deps, p, rec, routeRootCause, { cleanPass, commit });
     return { kind: 'done', ctx: active };

package/dist/task/widget.js

@@ -115,8 +115,6 @@ export function buildWidgetData(s) {
 }
 // ─── Widget lifecycle ────────────────────────────────────────────────────────
 export function startWidget(ctx, getState) {
-    if (!ctx.hasUI)
-        return () => { };
     // pi's `ctx.ui` getter calls `runner.assertActive()`, which THROWS once the
     // ctx goes stale (/reload, session replacement) — so the theme read belongs
     // INSIDE the guard, not one line above it. render() runs from a timer, and a
@@ -128,7 +126,12 @@ export function startWidget(ctx, getState) {
         if (stale)
             return;
         const s = getState();
-        const plain = s ? buildWidgetLines(s, undefined) : undefined; // un-themed for the wire; needs no ctx
+        // The wire half FIRST, and unguarded: it needs no ctx, so gating it on a
+        // local terminal that may not exist would leave a headless host's browser
+        // with no phase, no progress and no failure flash.
+        setTaskWidget(s ? buildWidgetLines(s, undefined) : undefined, s ? buildWidgetData(s) : null);
+        if (!ctx.hasUI)
+            return;
         try {
             const lines = s ? buildWidgetLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(WIDGET_KEY, lines);
@@ -136,9 +139,7 @@ export function startWidget(ctx, getState) {
         catch {
             stale = true;
             clearInterval(timer);
-            return;
         }
-        setTaskWidget(plain, s ? buildWidgetData(s) : null);
     };
     // The timer is created BEFORE the first render so `timer` is always bound
     // when render's catch reaches for it. Calling render() first instead would
@@ -208,16 +209,15 @@ export function buildAutoLoaderData(s) {
  * (returns a no-op disposer) when there's no UI.
  */
 export function startAutoLoader(ctx, getState) {
-    if (!ctx.hasUI)
-        return () => { };
-    // Same staleness hazard as startWidget: the theme read must sit inside the
-    // guard, and a stale ctx stops the timer rather than throwing every tick.
+    // Same staleness hazard as startWidget, and the same wire-half-first order.
     let stale = false;
     const render = () => {
         if (stale)
             return;
         const s = getState();
-        const plain = s ? buildAutoLoaderLines(s, undefined) : undefined; // needs no ctx
+        setTaskWidget(s ? buildAutoLoaderLines(s, undefined) : undefined, s ? buildAutoLoaderData(s) : null);
+        if (!ctx.hasUI)
+            return;
         try {
             const lines = s ? buildAutoLoaderLines(s, ctx.ui.theme) : undefined;
             ctx.ui.setWidget(AUTO_WIDGET_KEY, lines);
@@ -225,9 +225,7 @@ export function startAutoLoader(ctx, getState) {
         catch {
             stale = true;
             clearInterval(timer);
-            return;
         }
-        setTaskWidget(plain, s ? buildAutoLoaderData(s) : null);
     };
     // The timer is created BEFORE the first render so `timer` is always bound
     // when render's catch reaches for it. Calling render() first instead would
@@ -277,40 +275,33 @@ export function buildImplData(s) {
     return d;
 }
 export function flashTerminalWidget(ctx, state, taskId, reason) {
-    if (!ctx.hasUI)
-        return;
-    // Same staleness hazard as the render timers: bail rather than throw.
-    let theme;
-    try {
-        theme = ctx.ui.theme;
-    }
-    catch {
-        return;
-    }
-    let line;
-    let clearMs;
-    if (state === 'cancelled') {
-        line = theme.fg('warning', `⚠ ${taskId} cancelled`);
-        clearMs = NOTIFY_CLEAR_MS;
-    }
-    else {
-        line = theme.fg('error', `✘ ${taskId} failed${reason ? ': ' + reason : ''}`);
-        clearMs = FAIL_CLEAR_MS;
-    }
     const plainLine = state === 'cancelled' ?
         `⚠ ${taskId} cancelled`
         : `✘ ${taskId} failed${reason ? ': ' + reason : ''}`;
-    try {
-        ctx.ui.setWidget(WIDGET_KEY, [line]);
-        setTaskWidget([plainLine]);
-    }
-    catch {
-        /* stale ctx */
+    const clearMs = state === 'cancelled' ? NOTIFY_CLEAR_MS : FAIL_CLEAR_MS;
+    setTaskWidget([plainLine]);
+    // The wire half is already done, so a missing or stale local ctx no longer
+    // costs the browser the flash as well. Same staleness hazard as the render
+    // timers: bail rather than throw.
+    if (ctx.hasUI) {
+        try {
+            const theme = ctx.ui.theme;
+            const tint = state === 'cancelled' ? 'warning' : 'error';
+            ctx.ui.setWidget(WIDGET_KEY, [theme.fg(tint, plainLine)]);
+        }
+        catch {
+            /* stale ctx */
+        }
     }
     setTimeout(() => {
+        // Wire first, for the same reason as the flash above: a ctx that went
+        // stale in the meantime would otherwise leave the browser showing the
+        // flash for the rest of the session.
+        setTaskWidget(undefined);
+        if (!ctx.hasUI)
+            return;
         try {
             ctx.ui.setWidget(WIDGET_KEY, undefined);
-            setTaskWidget(undefined);
         }
         catch {
             /* stale ctx */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.39.1",
+    "version": "0.39.3",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",