@mjasnikovs/pi-task 0.39.2 → 0.39.3

package/dist/remote/ui-styles.js

@@ -121,6 +121,9 @@ export const STYLES = `    :root {
     /* Persistent inline system note (e.g. context compaction) — a muted centered
        divider, distinct from chat bubbles. */
     .sysnote {
+      /* publishNote sends multi-line text (the /task-config table); textContent
+         keeps the newlines only if the box does not collapse them. */
+      white-space: pre-wrap;
       align-self: center; color: var(--subtext0); font-size: 11px;
       font-family: ui-monospace, monospace; letter-spacing: 0.5px;
       padding: 2px 10px; opacity: 0.85;
@@ -414,10 +417,6 @@ export const STYLES = `    :root {
       background: var(--surface1); color: var(--text); z-index: 60; }
     .toast.warning { background: var(--peach); color: var(--crust); }
     .toast.error { background: var(--red); color: var(--crust); }
-    #viewer { position: fixed; inset: 24px; background: var(--mantle); border: 1px solid var(--surface2);
-      border-radius: 8px; padding: 16px; overflow: auto; white-space: pre-wrap;
-      overflow-wrap: anywhere; word-break: break-word; display: none; z-index: 70; }
-    #viewer .close { position: absolute; top: 8px; right: 12px; cursor: pointer; color: var(--subtext0); }
     /* Desktop: center the transcript/status/input in a readable column instead of
        hugging the left edge. The scrollbar stays at the true window edge; only the
        content is inset. Mobile (below 960px) is unchanged. */

package/dist/remote/ui.js

@@ -79,7 +79,6 @@ ${STYLES}
     <textarea id="prompt-input" rows="3" placeholder="Type your answer…" style="display:none"></textarea>
     <div class="row" id="prompt-buttons"></div>
   </div>
-  <div id="viewer"><span class="close" id="viewer-close">&#x2715;</span><div id="viewer-body"></div></div>
   <script>
 ${renderModule()}
 ${highlightModule()}

package/dist/task/auto-orchestrator.js

@@ -26,7 +26,7 @@ import { isFatalChildCause, prependHint, USER_CANCELLED } from './child-runner.j
 import { requestCancel, resetCancel, isCancelRequested, cancelCheckpoint } from './cancel-points.js';
 import { withRun, announceTerminal } from './run-bracket.js';
 import { refineExistingFilesBlock, SINGLE_READ_EXTENSION_PATH } from './phases.js';
-import { SessionUI, registerBridgeCommand, publishLifecycleNotice } from '../remote/bridge.js';
+import { SessionUI, registerBridgeCommand, publishLifecycleNotice, notifyBoth, notifyRun, isRemoteOrigin } from '../remote/bridge.js';
 import { getParentContextWindow } from './context-usage.js';
 import { ChildStatus, runPlanningChild, statusCallbacks } from './child-status.js';
 import { buildGateDeps, collectTreeChanges } from './gate-deps.js';
@@ -421,7 +421,7 @@ async function schedulePendingRepairs(cwd, id, afterIndex, ctx, deps) {
             titles.splice(at + 1, 0, title);
             at += 1;
             await deps.record?.(cwd, id, `plan: inserted scoped repair step after step ${afterIndex + 1} — ${title}`);
-            ctx.ui.notify(`${id}: queued a scoped repair for ${repair.file} (${repair.owner}'s file — root cause of ${repair.blamed.join(', ')}).`, 'warning');
+            notifyRun(ctx, `${id}: queued a scoped repair for ${repair.file} (${repair.owner}'s file — root cause of ${repair.blamed.join(', ')}).`, 'warning');
         }
     }
     catch {
@@ -623,7 +623,7 @@ export async function elicitClarifications(ctx, cwd, deps, oriented) {
         }
     }
     if (transcript.length === 0) {
-        ctx.ui.notify('No clarifying questions needed — planning tasks…', 'info');
+        notifyBoth(ctx, 'No clarifying questions needed — planning tasks…', 'info');
     }
     return transcript.forRecord();
 }
@@ -844,7 +844,7 @@ export async function coverPlan(ctx, cwd, deps, oriented, clarifications, decomp
             // mode (bare verdict, indistinguishable from a real one). The plan still
             // ships — the floor never rejects on count — but never silently.
             if (best.suspect) {
-                ctx.ui.notify(`/task-auto: only ${best.plan.titles.length} task(s) planned for a large spec`
+                notifyRun(ctx, `/task-auto: only ${best.plan.titles.length} task(s) planned for a large spec`
                     + ' and the regeneration did not grow the list — review the plan before running.', 'warning');
             }
             break;
@@ -889,7 +889,7 @@ export async function coverPlan(ctx, cwd, deps, oriented, clarifications, decomp
     if (unresolvedMissing !== null) {
         logPlanDebug(cwd, `decompose-coverage exhausted ${round} round(s) still INCOMPLETE — missing: `
             + unresolvedMissing.join('; ').slice(0, 300));
-        ctx.ui.notify(`/task-auto: no task fully owns — ${unresolvedMissing.join('; ').slice(0, 200)}. `
+        notifyRun(ctx, `/task-auto: no task fully owns — ${unresolvedMissing.join('; ').slice(0, 200)}. `
             + 'Carried into every task via .pi-tasks/requirements.md, but not as a dedicated '
             + 'task. To give it one, stop now and add it to the plan in .pi-tasks/; otherwise '
             + 'it proceeds.', 'warning');
@@ -966,7 +966,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
             carriedJudge.length > 0 ? `${carriedJudge.length} judge-flagged` : '',
             carriedDangling.length > 0 ? `${carriedDangling.length} dangling-artifact` : ''
         ].filter(p => p.length > 0);
-        ctx.ui.notify(`/task-auto: carrying ${parts.join(', ')} requirement(s) into every task`
+        notifyRun(ctx, `/task-auto: carrying ${parts.join(', ')} requirement(s) into every task`
             + ' — see .pi-tasks/requirements.md.', 'info');
     }
     // Thread the feature's spec doc(s) into every title so each per-task
@@ -1191,7 +1191,7 @@ async function reportStashDrift(active, deps, cwd, id, title, before) {
         const after = await deps.stashRef(cwd);
         if (after === before)
             return;
-        active.ui.notify(`${id}: the git stash stack changed during "${title}" and was left that way — `
+        notifyRun(active, `${id}: the git stash stack changed during "${title}" and was left that way — `
             + 'inspect `git stash list`; an orphan stash later pops as an unresolvable conflict.', 'warning');
     }
     catch {
@@ -1269,8 +1269,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             // never learns how far the run has gotten — mirror it into the session
             // view too (transient toast, same as announceDone's info path).
             const progressMsg = `${id}: task ${next.index + 1}/${entries.length} — ${next.title}`;
-            active.ui.notify(progressMsg, 'info');
-            publishLifecycleNotice(progressMsg, 'info');
+            notifyBoth(active, progressMsg, '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. But the stamped inner file can be gone
@@ -1298,7 +1297,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
             // 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');
+                notifyRun(active, `${id}: checkpointed uncommitted work before "${next.title}".`, 'info');
             }
             // Stash ref before the task: compared after the gates so a stash pushed
             // during the task (impl model or any child) and left behind is called
@@ -1444,8 +1443,11 @@ async function handleTaskAuto(args, ctx) {
     const cwd = ctx.cwd;
     const raw = args.trim();
     if (raw.length === 0) {
-        ctx.ui.setEditorText('/task-auto ');
-        ctx.ui.notify('Describe the feature after /task-auto (use @ for file completion).', 'info');
+        // Prefilling the composer answers a LOCAL user. From the browser it would
+        // type into a terminal nobody is sitting at; the notice is the answer there.
+        if (!isRemoteOrigin(ctx))
+            ctx.ui.setEditorText('/task-auto ');
+        notifyBoth(ctx, 'Describe the feature after /task-auto (use @ for file completion).', 'info');
         return;
     }
     autoRunning = true;
@@ -1506,11 +1508,13 @@ async function handleTaskAutoResume(args, ctx) {
         : await findResumableAutoDetailed(cwd);
     const candidate = eligible ?? (unattended ? await findResumableAutoDetailed(cwd) : null);
     const decision = decideResume(candidate, Date.now(), unattended);
-    ctx.ui.notify(decision.banner, decision.level);
     // An unattended refusal happens with nobody watching the terminal — the
-    // remote view is the only surface that will still be there in the morning.
+    // remote view is the only surface that will still be there in the morning,
+    // which is why it is a run notice and not a toast.
     if (unattended)
-        publishLifecycleNotice(decision.banner, decision.level);
+        notifyRun(ctx, decision.banner, decision.level);
+    else
+        notifyBoth(ctx, decision.banner, decision.level);
     if (!decision.resume || !candidate)
         return;
     const id = candidate.id;
@@ -1543,10 +1547,12 @@ async function handleTaskAutoResume(args, ctx) {
 async function handleTaskAutoCancel(_args, ctx) {
     if (!autoRunning) {
         ctx.ui.notify('No /task-auto loop is running.', 'info');
+        publishLifecycleNotice('No /task-auto loop is running.', 'info');
         return;
     }
     requestAutoCancel();
     ctx.ui.notify(CANCEL_ACK, 'warning');
+    publishLifecycleNotice(CANCEL_ACK, 'warning');
 }
 /**
  * What the user is told the moment the request lands. Deliberately does NOT

package/dist/task/failure-classifier.js

@@ -4,7 +4,7 @@
  */
 import { updateTaskFrontMatter } from './task-io.js';
 import { flashTerminalWidget } from './widget.js';
-import { publishLifecycleNotice } from '../remote/bridge.js';
+import { notifyRun } from '../remote/bridge.js';
 import { ChildFailureError, USER_CANCELLED } from './child-runner.js';
 import { streamStallCause } from '../shared/stream-watchdog.js';
 // ─── Classifier ──────────────────────────────────────────────────────────────
@@ -80,9 +80,8 @@ export async function handleFailure(err, ctx, cwd, id, aborted) {
     const c = classifyFailure(err, aborted);
     await updateTaskFrontMatter(cwd, id, { state: c.state, reason: c.reason });
     flashTerminalWidget(ctx, c.state, id, c.flash);
-    ctx.ui.notify(`${id} ${c.notify}`, c.level);
-    // Mirror to remote viewers. `ctx.ui.notify` reaches the terminal UI only, so
-    // without this call the remote view shows nothing when a task fails.
-    publishLifecycleNotice(`${id} ${c.notify}`, c.level);
+    // How the run ENDED. Durable on the remote: a toast is gone before an absent
+    // user looks, and this is the one line that says the task did not finish.
+    notifyRun(ctx, `${id} ${c.notify}`, c.level);
     return c;
 }

package/dist/task/gate-child.js

@@ -26,6 +26,7 @@
  */
 import { formatLoopHint } from './loop-detector.js';
 import { classifyEnforceChildFailure } from './enforce-guidelines.js';
+import { notifyRun } from '../remote/bridge.js';
 /**
  * What each kind may do. Adding a child is a row; it cannot be added without
  * deciding all four questions, which is the point.
@@ -145,7 +146,7 @@ export function makeGateChild(deps) {
                         log(`=== ${deps.kind} GIT-STATE GUARD — ${label}; `
                             + `restored: ${rec.actions.join('; ')} ===`);
                         if (rec.verdictTainted) {
-                            deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} child mutated repo state — `
+                            notifyRun(deps.ctx, `${deps.taskTitle}: ${deps.kind} child mutated repo state — `
                                 + `restored (${rec.actions.join('; ').slice(0, 140)}).`, 'warning');
                         }
                     }
@@ -156,7 +157,7 @@ export function makeGateChild(deps) {
             // only thing that can block.
             if (r.loopHit) {
                 log(`=== ${deps.kind} LOOP WARNING — ${formatLoopHint(r.loopHit)} ===`);
-                deps.ctx.ui.notify(`${deps.taskTitle}: ${deps.kind} worker looped past the nudges — `
+                notifyRun(deps.ctx, `${deps.taskTitle}: ${deps.kind} worker looped past the nudges — `
                     + 'continuing (not blocked).', 'warning');
             }
             const failure = classifyEnforceChildFailure(r);

package/dist/task/orchestrator.js

@@ -27,7 +27,7 @@ import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSecti
 import { startWidget } from './widget.js';
 import { setupImplWidget } from './impl-widget.js';
 import { enterImplementationTurn } from './implementation-scope.js';
-import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
+import { SessionUI, publishNotify, registerBridgeCommand, getBridge, notifyBoth, isRemoteOrigin } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { getConfig } from '../config/config.js';
 import { gateDebugWriter } from './debug-log.js';
@@ -681,8 +681,11 @@ async function handleTask(args, ctx) {
     const cwd = ctx.cwd;
     const raw = args.trim();
     if (raw.length === 0) {
-        ctx.ui.setEditorText('/task ');
-        ctx.ui.notify('Type your prompt after /task (use @ for file completion).', 'info');
+        // Prefilling the composer answers a LOCAL user. From the browser it would
+        // type into a terminal nobody is sitting at; the notice is the answer there.
+        if (!isRemoteOrigin(ctx))
+            ctx.ui.setEditorText('/task ');
+        notifyBoth(ctx, 'Type your prompt after /task (use @ for file completion).', 'info');
         return;
     }
     // When a gate is enabled, /task awaits the implementation and runs the same
@@ -696,7 +699,7 @@ async function handleTask(args, ctx) {
     }
     const { end } = await runSingleTask(ctx, cwd, raw, { notifyFinish: true });
     if (end.kind === 'no-session') {
-        ctx.ui.notify('Could not start a fresh session for /task.', 'warning');
+        notifyBoth(ctx, 'Could not start a fresh session for /task.', 'warning');
     }
 }
 async function handleTaskList(_args, ctx) {
@@ -729,8 +732,12 @@ async function handleTaskList(_args, ctx) {
     if (lines.length === 0)
         lines.push('(no tasks in .pi-tasks/)');
     lines.push('', 'resume: /task-resume <id>   (eligible: in_progress, pending, cancelled, failed)');
-    publishViewer('Tasks', lines.join('\n'));
-    await ctx.ui.editor('Tasks', lines.join('\n'));
+    await new SessionUI(ctx).show({
+        localTitle: 'Tasks',
+        localText: lines.join('\n'),
+        question: 'Tasks',
+        body: lines.join('\n')
+    });
 }
 async function handleTaskResume(args, ctx) {
     await ctx.waitForIdle();
@@ -742,8 +749,7 @@ async function handleTaskResume(args, ctx) {
             await fsp.access(taskFilePath(cwd, id));
         }
         catch {
-            ctx.ui.notify(`${id} not found in .pi-tasks/`, 'error');
-            publishNotify(`${id} not found in .pi-tasks/`, 'error');
+            notifyBoth(ctx, `${id} not found in .pi-tasks/`, 'error');
             return;
         }
     }
@@ -771,8 +777,7 @@ async function handleTaskResume(args, ctx) {
         }
         candidates.sort((a, b) => b.mtime - a.mtime);
         if (candidates.length === 0) {
-            ctx.ui.notify('No resumable tasks.', 'info');
-            publishNotify('No resumable tasks.', 'info');
+            notifyBoth(ctx, 'No resumable tasks.', 'info');
             return;
         }
         id = candidates[0].id;
@@ -785,19 +790,17 @@ async function handleTaskResume(args, ctx) {
     }
     const { end } = await runSingleTask(ctx, cwd, '', { resumeId: id, notifyFinish: true });
     if (end.kind === 'no-session') {
-        ctx.ui.notify('Could not start a fresh session for /task-resume.', 'warning');
+        notifyBoth(ctx, 'Could not start a fresh session for /task-resume.', 'warning');
     }
 }
 // eslint-disable-next-line @typescript-eslint/require-await
 async function handleTaskCancel(_args, ctx) {
     if (!activeTask) {
-        ctx.ui.notify('No task is running.', 'info');
-        publishNotify('No task is running.', 'info');
+        notifyBoth(ctx, 'No task is running.', 'info');
         return;
     }
     activeTask.cancel();
-    ctx.ui.notify(`Cancelling ${activeTask.taskId}…`, 'warning');
-    publishNotify(`Cancelling ${activeTask.taskId}…`, 'warning');
+    notifyBoth(ctx, `Cancelling ${activeTask.taskId}…`, 'warning');
 }
 // ─── Entry point ─────────────────────────────────────────────────────────────
 export function registerTask(pi) {

package/dist/task/phases.js

@@ -40,7 +40,7 @@ import { detachUnsatisfiableRequirements, claimPendingRequirements, unclaimedPen
 import { trackedSourceOracle } from './owned-freeze-conflict.js';
 import { groupArgsForChild, runPhaseChild, runWithEmphasisRetry, prependHint, USER_CANCELLED, ChildFailureError, isFatalChildCause } from './child-runner.js';
 import { runResearchWorker, researchWorkerCacheHeading } from './research-worker.js';
-import { SessionUI } from '../remote/bridge.js';
+import { SessionUI, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, yoloPickAutoAnswer } from './yolo.js';
 import { QaTranscript, GRILL_QA_POLICY } from './qa-transcript.js';
 // ─── Re-export constants from their home modules ────────────────────────────
@@ -1113,7 +1113,7 @@ export async function critiqueWithFallback(d, p) {
         // it is the validated-shape fallback, and failing the run costs more.
         if (parseVerifyBlock(p.spec) === null)
             throw err;
-        p.ctx.ui.notify(msg === 'verify_grep_theater' ?
+        notifyRun(p.ctx, msg === 'verify_grep_theater' ?
             'Critique rewrite kept a grep-only VERIFY — using compose draft. Consider adding a command that RUNS the deliverable.'
             : "Critique couldn't produce a VERIFY block — using compose draft. Edit the spec manually if needed.", 'warning');
         return p.spec;

package/dist/task/plan-orchestrator.js

@@ -34,7 +34,7 @@ import { deriveTitle } from './parsers.js';
 import { renderInlineMarkdown } from './inline-markdown.js';
 import { expandFeatureMentions } from './auto-orchestrator.js';
 import { runSingleTask, runGatedTask } from './orchestrator.js';
-import { SessionUI, publishViewer, publishLifecycleNotice, registerBridgeCommand } from '../remote/bridge.js';
+import { SessionUI, registerBridgeCommand, notifyBoth, notifyRun, isRemoteOrigin } from '../remote/bridge.js';
 import { withRun, announceTerminal } from './run-bracket.js';
 import { getConfig } from '../config/config.js';
 import { isYoloMode } from './yolo.js';
@@ -121,9 +121,12 @@ export function buildPlanDeps(ctx, cwd, planId, task, signal) {
             allowSkip: true
         }),
         showAnswer: async (question, answer) => {
-            const text = `You asked:\n${question}\n\n${answer}\n`;
-            publishViewer(ASK_TITLE, text);
-            await ctx.ui.editor(ASK_TITLE, text);
+            await ui.show({
+                localTitle: ASK_TITLE,
+                localText: `You asked:\n${question}\n\n${answer}\n`,
+                question: `You asked: ${question}`,
+                body: answer
+            });
         },
         onEntries: async (entries) => {
             await persistEntries(cwd, planId, entries);
@@ -147,13 +150,7 @@ export function buildPlanDeps(ctx, cwd, planId, task, signal) {
 async function reportReadOnlyViolation(ctx, cwd, planId, step, touched, logDebug) {
     const line = formatReadOnlyViolation(step, touched);
     logDebug?.(line);
-    try {
-        ctx.ui.notify(line, 'error');
-    }
-    catch {
-        /* stale ctx — the record below is what matters */
-    }
-    publishLifecycleNotice(line, 'error');
+    notifyRun(ctx, line, 'error');
     try {
         const existing = (await readSection(cwd, planId, 'read-only violations')) ?? '';
         await setTaskSection(cwd, planId, 'read-only violations', existing ? `${existing}\n- ${line}` : `- ${line}`);
@@ -193,7 +190,7 @@ async function defaultHandoff(ctx, cwd, prompt) {
     }
     const { taskId, end } = await runSingleTask(ctx, cwd, prompt, { notifyFinish: true });
     if (end.kind === 'no-session') {
-        ctx.ui.notify('Could not start a fresh session for /task-plan.', 'warning');
+        notifyBoth(ctx, 'Could not start a fresh session for /task-plan.', 'warning');
         return undefined;
     }
     return taskId || undefined;
@@ -239,8 +236,11 @@ export async function handleTaskPlan(args, ctx, commandDeps = DEFAULT_COMMAND_DE
     const cwd = ctx.cwd;
     const raw = args.trim();
     if (raw.length === 0) {
-        ctx.ui.setEditorText('/task-plan ');
-        ctx.ui.notify('Describe the task after /task-plan (use @ for file completion).', 'info');
+        // Prefilling the composer answers a LOCAL user. From the browser it would
+        // type into a terminal nobody is sitting at; the notice is the answer there.
+        if (!isRemoteOrigin(ctx))
+            ctx.ui.setEditorText('/task-plan ');
+        notifyBoth(ctx, 'Describe the task after /task-plan (use @ for file completion).', 'info');
         return;
     }
     // Inline any @file the user referenced, exactly as /task-auto's planner does:

package/dist/task/run-final-gate.js

@@ -1,7 +1,7 @@
 import { AutofixLedger } from './autofix-ledger.js';
 import { describeDebt, recordDebt } from './accept-debt.js';
 import { cancelCheckpoint } from './cancel-points.js';
-import { SessionUI } from '../remote/bridge.js';
+import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, yoloFinalGateChoice, YOLO_STAMP } from './yolo.js';
 import { ignoredWriteTrailLine, ignoredWriteDebtReason } from './write-guard.js';
 import { readOwnedRequirements } from './requirements.js';
@@ -76,7 +76,7 @@ export async function runFinalGateStage(active, deps, p) {
     // Set when the gate finished having observed NOTHING dynamic. Declared out here so
     // the run-completion announcement can say so.
     let unobservedNote = null;
-    active.ui.notify(`${id}: running final integration gate…`, 'info');
+    notifyBoth(active, `${id}: running final integration gate…`, 'info');
     // Run-level gate trail on the parent task file — same durable auditability
     // contract as the per-task `## gates` records.
     const recGate = async (line) => {
@@ -111,7 +111,7 @@ export async function runFinalGateStage(active, deps, p) {
         unobservedNote = fin.unobserved;
         await recGate(`final-gate: UNOBSERVED — ${fin.reason.slice(0, 300)}`);
         await carryDebt(fin.unobserved);
-        active.ui.notify(`${id}: the final integration gate observed NOTHING dynamic — `
+        notifyRun(active, `${id}: the final integration gate observed NOTHING dynamic — `
             + 'the run completed on static checks alone. Nothing verified '
             + 'that the assembled product builds, boots or works.', 'warning');
     }
@@ -132,7 +132,7 @@ export async function runFinalGateStage(active, deps, p) {
         for (const d of debts) {
             await recGate(`defect STILL OPEN — ${d.taskId || '(unknown task)'}: ${describeDebt(d)}: ${d.reason.slice(0, 240)}${d.conflict ? ` [CONFLICTING CLAIM — ${d.conflict}]` : ''}`);
         }
-        active.ui.notify(`${id}: ${debts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
+        notifyRun(active, `${id}: ${debts.length} recorded verify-FAIL defect(s) are STILL unresolved at run end — see the gate trail.`, 'warning');
     };
     // What was REPORTED, so a post-autofix re-derivation can be compared against it
     // rather than blindly re-printed.
@@ -149,7 +149,7 @@ export async function runFinalGateStage(active, deps, p) {
             + ` ${(o.pending ?? []).join(', ')}]`);
     }
     if (unclaimed.length > 0) {
-        active.ui.notify(`${id}: ${unclaimed.length} authoritative design requirement(s) ended the run`
+        notifyRun(active, `${id}: ${unclaimed.length} authoritative design requirement(s) ended the run`
             + ' owned by NO task — the task they were mapped to could not touch the'
             + ' file, and nothing else claimed it. See the gate trail.', 'warning');
     }
@@ -315,7 +315,7 @@ export async function runFinalGateStage(active, deps, p) {
             // commit — the ACCEPT is a decision about the FAILING gate, never an
             // instruction to throw away work.
             await commitStranded('accepted');
-            active.ui.notify(`${id}: final integration gate FAIL accepted by user — completing.`
+            notifyRun(active, `${id}: final integration gate FAIL accepted by user — completing.`
                 + (ledger.stranded().length > 0 ?
                     ` ${ledger.stranded().length} uncommitted fix-pass change(s) committed separately.`
                     : ''), 'warning');
@@ -324,7 +324,7 @@ export async function runFinalGateStage(active, deps, p) {
         if (choice.action === 'autofix' && canAutofix) {
             const attempt = ledger.attempt();
             await recGate(`final-gate: user chose AUTOFIX (attempt ${attempt}/${MAX_FINAL_GATE_AUTOFIX})`);
-            active.ui.notify(`${id}: final-gate autofix (${attempt}/${MAX_FINAL_GATE_AUTOFIX}) — bounded fix pass, then the gate re-runs…`, 'info');
+            notifyRun(active, `${id}: final-gate autofix (${attempt}/${MAX_FINAL_GATE_AUTOFIX}) — bounded fix pass, then the gate re-runs…`, 'info');
             const seed = choice.guidance ? `${fin.reason}\n\nUser guidance: ${choice.guidance}` : fin.reason;
             const fix = await deps.finalGateFix(active, cwd, seed, [...ledger.ignoredWrites()]);
             // IGNORED-PATH WRITES. The pass wrote file(s) git ignores, so
@@ -355,7 +355,7 @@ export async function runFinalGateStage(active, deps, p) {
                     await carryDebt(fix.unobserved);
                 }
                 await recGate(`final-gate: autofix ${fix.unobserved ? 'ended UNOBSERVED' : 'converged'} — ${fix.reason.slice(0, 200)}`);
-                active.ui.notify(`${id}: final integration gate ${fix.unobserved ? 'is UNOBSERVED' : 'PASSES'} after autofix — ${fix.reason.slice(0, 140)}`, fix.unobserved ? 'warning' : 'info');
+                notifyRun(active, `${id}: final integration gate ${fix.unobserved ? 'is UNOBSERVED' : 'PASSES'} after autofix — ${fix.reason.slice(0, 140)}`, fix.unobserved ? 'warning' : 'info');
                 // The gate's own outcome, WHOLE, with this door's reason on it.
                 // Rebuilding it as a two-key literal would drop `openDebts` and
                 // `observedFailures` from the value entirely.
@@ -380,7 +380,7 @@ export async function runFinalGateStage(active, deps, p) {
                 await recGate(`final-gate: autofix attempt ${attempt} left ${ledger.stranded().length} `
                     + `uncommitted change(s) — ${ledger.stranded().slice(0, 8).join(', ')}`);
             }
-            active.ui.notify(`${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
+            notifyRun(active, `${id}: final-gate autofix did not converge — ${fix.reason.slice(0, 140)}`, 'warning');
             // NON-PROGRESS CLASSIFIER. An attempt that changed the tree, re-ran the
             // gate, and got back the SAME ranked-first failure as the previous such
             // attempt is evidence about the CHECK, not about the fix — a check that
@@ -396,7 +396,7 @@ export async function runFinalGateStage(active, deps, p) {
                 await recGate(`final-gate: check DEMOTED to UNOBSERVED after ${attempt} tree-changing `
                     + `attempts returned an identical failure — carried as debt (origin final-gate) `
                     + `and re-checked by the next run's gate: ${verdict.detail.slice(0, 240)}`);
-                active.ui.notify(`${id}: final-gate check is unfalsifiable in this environment — carried as debt; `
+                notifyRun(active, `${id}: final-gate check is unfalsifiable in this environment — carried as debt; `
                     + 'the remaining checks decide convergence.', 'warning');
             }
             // Convergence on the REMAINING checks: a demoted signature no longer counts
@@ -409,7 +409,7 @@ export async function runFinalGateStage(active, deps, p) {
                     const converged = `converged on all remaining checks; ${ledger.demotedCount()} check(s) `
                         + 'carried as UNOBSERVED debt (unfalsifiable in this environment)';
                     await recGate(`final-gate: ${converged}`);
-                    active.ui.notify(`${id}: final integration gate converged — ${converged}.`, 'warning');
+                    notifyRun(active, `${id}: final integration gate converged — ${converged}.`, 'warning');
                     // The gate's own outcome, with this door's reason on it — the
                     // whole value, so `openDebts` survives the assignment.
                     fin = { ...fix.gate, ok: true, reason: converged };

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 };