@mjasnikovs/pi-task 0.39.2 → 0.39.4

package/dist/config/register.js

@@ -3,7 +3,7 @@ import { effectiveSetting, offeredLevels } from '../shared/reasoning-capability.
 import { resolveModel, specOf } from '../shared/model-resolve.js';
 import { MODEL_INHERIT } from './group-models.js';
 import { PairPicker } from './option-picker.js';
-import { registerBridgeCommand } from '../remote/bridge.js';
+import { registerBridgeCommand, isRemoteOrigin, publishNote } from '../remote/bridge.js';
 import { readPkgVersion } from '../shared/pkg-version.js';
 import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
 import { COMMAND_TIMEOUT_OPTIONS, DEBUG_LOG_OPTIONS, getConfig, sanitizeDebugLogs, saveConfig, STREAM_INACTIVITY_OPTIONS } from './config.js';
@@ -836,7 +836,10 @@ async function handleTaskConfig(_args, ctx, getTools = () => []) {
     // it can only be read here, when the menu opens, never at registration.
     const tools = getTools();
     const catalog = liveCatalog(ctx);
-    if (ctx.mode !== 'tui') {
+    // The panel is a TUI component. A browser caller has no way to draw it and no
+    // way to close it, so awaiting it there parks the remote on the host's
+    // terminal — the failure issue #1 fixed for /task-plan.
+    if (ctx.mode !== 'tui' || isRemoteOrigin(ctx)) {
         // Built from panelItems and reading the SAME `format` the panel does,
         // so the two renderings cannot disagree about what a setting says. A
         // second walk of the same tables is the one place nobody would notice
@@ -850,6 +853,9 @@ async function handleTaskConfig(_args, ctx, getTools = () => []) {
             `[${i.label.trim()}]`
             : `${(i.headlessLabel ?? i.label).padEnd(22)} ${i.currentValue}`);
         ctx.ui.notify(lines.join('  |  '), 'info');
+        // One row per line: the `|`-joined form is for a terminal that has one
+        // line to spare, and the browser has a whole transcript.
+        publishNote(lines.join('\n'));
         return;
     }
     // Built ONCE and shared by the renderer, the dispatch and the refresh, so

package/dist/config/tool-list.d.ts

@@ -28,6 +28,16 @@ export interface GuardableTool {
     /** Provenance shown in the menu, e.g. "built in" or "npm:pi-fable (/path)". */
     origin: string;
 }
+/**
+ * pi-task's own tools whose child already carries the guard the host watchdog
+ * would duplicate — and duplicate WRONGLY. `pi-worker` runs the `adhoc` profile
+ * (workers/worker-profiles.ts): no wall clock by decision, bounded on model
+ * SILENCE via `stuck reply retry`, plus the loop, churn and dead-backend guards.
+ * A host wall clock on top killed healthy workers at the command ceiling while
+ * they were still reading. Never armed, never offered as a `watch:` row: the
+ * operator should not be handed a switch that is only ever correct one way.
+ */
+export declare const SELF_BOUNDED_TOOLS: ReadonlySet<string>;
 /**
  * Every tool in the live session, built-ins first and each extension's tools in
  * registration order after them, so the menu reads owner-by-owner.

package/dist/config/tool-list.js

@@ -1,5 +1,15 @@
 /** The `source` pi reports for its own tools rather than an extension's. */
 const BUILTIN_SOURCE = 'builtin';
+/**
+ * pi-task's own tools whose child already carries the guard the host watchdog
+ * would duplicate — and duplicate WRONGLY. `pi-worker` runs the `adhoc` profile
+ * (workers/worker-profiles.ts): no wall clock by decision, bounded on model
+ * SILENCE via `stuck reply retry`, plus the loop, churn and dead-backend guards.
+ * A host wall clock on top killed healthy workers at the command ceiling while
+ * they were still reading. Never armed, never offered as a `watch:` row: the
+ * operator should not be handed a switch that is only ever correct one way.
+ */
+export const SELF_BOUNDED_TOOLS = new Set(['pi-worker']);
 /**
  * Human provenance for a tool's source metadata. `source` is pi's own word for
  * where the owner came from ("builtin", "npm:...", "auto", "cli"); the two
@@ -30,7 +40,7 @@ export function toGuardableTools(tools) {
         // A duplicate name cannot be told apart by the watchdog (it only ever
         // sees `toolName`), so a second registration must not add a second row
         // that silently toggles the first one's guard.
-        if (seen.has(t.name))
+        if (seen.has(t.name) || SELF_BOUNDED_TOOLS.has(t.name))
             continue;
         seen.add(t.name);
         const entry = { name: t.name, origin: toolOrigin(t.sourceInfo.source, t.sourceInfo.path) };

package/dist/remote/bridge.d.ts

@@ -17,6 +17,17 @@ export declare function getBridge(): BridgeState;
 /** Resolve the remote side of a pending prompt. First call wins; later calls
  *  (duplicate frames, a second browser, local-after-remote) are ignored. */
 export declare function answerPrompt(id: string, value: string | undefined): void;
+/**
+ * Settle every parked ask with undefined. Its one caller is the remote `/new`,
+ * whose reset wipes the prompt slot and tells the browser to close its card,
+ * leaving the resolver here with no surface on any device — and, on a host with
+ * no TUI, no local half either.
+ *
+ * Deliberately NOT on every `session_start`: that also fires for the /task
+ * handoff's own newSession, where cancelling would read to the planner as the
+ * user skipping a question they were never shown.
+ */
+export declare function cancelPendingPrompts(): void;
 export interface AskSpec {
     /** Themed, possibly multi-line title for the local TUI input. */
     localTitle: string;
@@ -86,6 +97,17 @@ export interface AskSpec {
         value: string;
     }[];
 }
+/** A read-only display fanned out to both surfaces by {@link SessionUI.show}. */
+export interface ShowSpec {
+    /** Title for the local terminal editor. */
+    localTitle: string;
+    /** Full text the local editor opens with. */
+    localText: string;
+    /** Card header on the browser. Plain text. */
+    question: string;
+    /** Card body on the browser, markdown-rendered in the panel. */
+    body: string;
+}
 /** Wraps a live command ctx and fans interactions out to local TUI + browsers. */
 export declare class SessionUI {
     private readonly ctx;
@@ -95,6 +117,22 @@ export declare class SessionUI {
     get hasUI(): boolean;
     /** Race the local input against a remote answer; first to settle wins. */
     ask(spec: AskSpec): Promise<string | undefined>;
+    /**
+     * Show text that only needs dismissing. Locally that is the terminal editor;
+     * remotely it is a dismiss-only prompt card, and it has to be a prompt rather
+     * than a `viewer` because only the prompt slot is in the reconnect snapshot
+     * and only a prompt can settle the caller from the browser.
+     *
+     * pi's `ui.editor` takes no AbortSignal, so a remote dismissal cannot close
+     * the terminal editor the way a remote answer aborts a local ask. It is left
+     * open and whatever it eventually returns is discarded — the run has moved on.
+     */
+    show(spec: ShowSpec): Promise<void>;
+    /**
+     * The shared half of ask() and show(): publish one prompt card, open the
+     * local dialog beside it, and take whichever settles first.
+     */
+    private race;
     /**
      * The local-TUI half of ask(). With `spec.options` it renders the boxed
      * picker (each answer in its own bounding box, the first/recommended one
@@ -126,7 +164,33 @@ export declare function interruptAgent(): void;
  * transient toast since they don't need to linger.
  */
 export declare function publishLifecycleNotice(message: string, level: 'info' | 'warning' | 'error'): void;
-export declare function publishViewer(title: string, text: string): void;
+/**
+ * Say it on BOTH surfaces. The local notify is attempted first and its failure
+ * absorbed — a stale ctx must not cost the remote the message, which is the one
+ * surface still there when nobody is at the terminal.
+ */
+export declare function notifyBoth(ctx: Pick<ExtensionCommandContext, 'ui'>, message: string, level: 'info' | 'warning' | 'error'): void;
+/** {@link notifyBoth} for something that must outlive a toast — see
+ *  {@link publishRunNotice}. */
+export declare function notifyRun(ctx: Pick<ExtensionCommandContext, 'ui'>, message: string, level: 'info' | 'warning' | 'error'): void;
+/**
+ * A run outcome the remote must still have later: what a gate decided, what a
+ * commit failed to do, what a resume refused. Unlike publishLifecycleNotice it
+ * persists at EVERY level, because "still there in the morning" is the reason
+ * these are published at all — a warning that vanishes after four seconds tells
+ * an absent user nothing.
+ */
+export declare function publishRunNotice(message: string, level: 'info' | 'warning' | 'error'): void;
+/** Commit text to the remote transcript. Unlike a notify it is in the reconnect
+ *  snapshot, so it is still there after a refresh. */
+export declare function publishNote(text: string): void;
+/**
+ * True when this ctx reached the handler through the browser rather than the
+ * terminal. A command that can only draw itself on the host TUI must check it:
+ * awaiting a local overlay for a remote caller parks the browser on a dialog
+ * nobody is sitting in front of.
+ */
+export declare function isRemoteOrigin(ctx: ExtensionCommandContext): boolean;
 /**
  * Wraps an event-scoped ExtensionContext so it can be used as a command ctx
  * for commands that don't need newSession (e.g. /task-resume, /task-list,

package/dist/remote/bridge.js

@@ -1,6 +1,6 @@
 import { broadcast as wsBroadcast } from './broadcast.js';
 import { pushNotify } from './push.js';
-import { setPrompt, clearPrompt, addError } from './session-state.js';
+import { setPrompt, clearPrompt, addError, addSystemNote, getState } from './session-state.js';
 import { askQuestionBox } from '../task/question-box.js';
 const g = globalThis;
 export function getBridge() {
@@ -26,6 +26,22 @@ export function answerPrompt(id, value) {
     b.pending.delete(id);
     settle(value);
 }
+/**
+ * Settle every parked ask with undefined. Its one caller is the remote `/new`,
+ * whose reset wipes the prompt slot and tells the browser to close its card,
+ * leaving the resolver here with no surface on any device — and, on a host with
+ * no TUI, no local half either.
+ *
+ * Deliberately NOT on every `session_start`: that also fires for the /task
+ * handoff's own newSession, where cancelling would read to the planner as the
+ * user skipping a question they were never shown.
+ */
+export function cancelPendingPrompts() {
+    const b = getBridge();
+    for (const settle of b.pending.values())
+        settle(undefined);
+    b.pending.clear();
+}
 /** Wraps a live command ctx and fans interactions out to local TUI + browsers. */
 export class SessionUI {
     ctx;
@@ -42,35 +58,78 @@ export class SessionUI {
     }
     /** Race the local input against a remote answer; first to settle wins. */
     async ask(spec) {
-        const b = this.bridge;
-        const id = String(b.nextId++);
-        const ac = new AbortController();
-        const remote = new Promise(resolve => {
-            b.pending.set(id, resolve);
-        });
-        const prompt = {
+        return this.race(id => ({
             type: 'prompt',
             id,
             question: spec.question,
             recommended: spec.recommended,
             ...(spec.recommended2 !== undefined && { recommended2: spec.recommended2 }),
-            ...(spec.actions !== undefined && spec.actions.length > 0 && { actions: spec.actions }),
+            ...(spec.actions !== undefined
+                && spec.actions.length > 0 && { actions: spec.actions }),
             allowSkip: spec.allowSkip
-        };
-        setPrompt(prompt);
-        // 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(() => { });
+        }), spec.question, signal => this.askLocal(spec, signal));
+    }
+    /**
+     * Show text that only needs dismissing. Locally that is the terminal editor;
+     * remotely it is a dismiss-only prompt card, and it has to be a prompt rather
+     * than a `viewer` because only the prompt slot is in the reconnect snapshot
+     * and only a prompt can settle the caller from the browser.
+     *
+     * pi's `ui.editor` takes no AbortSignal, so a remote dismissal cannot close
+     * the terminal editor the way a remote answer aborts a local ask. It is left
+     * open and whatever it eventually returns is discarded — the run has moved on.
+     */
+    async show(spec) {
+        // Nothing to wait for: with no local editor the only surface is the
+        // browser, and a DISPLAY that blocks a run until someone opens one is
+        // worse than a note nobody dismisses.
+        if (!this.ctx.hasUI) {
+            publishNote(`${spec.question}\n${spec.body}`);
+            return;
+        }
+        await this.race(id => ({
+            type: 'prompt',
+            id,
+            question: spec.question,
+            recommended: spec.body,
+            dismissOnly: true,
+            allowSkip: false
+        }), 
+        // No push: a read-only card is not a request for input, and waking a
+        // phone to say it is would be a lie.
+        null, () => this.ctx.ui.editor(spec.localTitle, spec.localText));
+    }
+    /**
+     * The shared half of ask() and show(): publish one prompt card, open the
+     * local dialog beside it, and take whichever settles first.
+     */
+    async race(build, pushBody, local) {
+        const b = this.bridge;
+        const id = String(b.nextId++);
+        const ac = new AbortController();
+        const remote = new Promise(resolve => {
+            b.pending.set(id, resolve);
+        });
+        // The slot holds one prompt. Whatever is in it is put BACK when this one
+        // settles, or a /task-list would leave a parked question unanswerable
+        // from every browser — off the card and out of the snapshot both.
+        const displaced = getState().prompt;
+        setPrompt(build(id));
+        if (pushBody !== null) {
+            // 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', pushBody, 'pi-prompt').catch(() => { });
+        }
         // Local: resolves to a value, or to undefined on cancel or abort. The
         // catch is belt-and-braces — a rejection here would surface as an
         // unhandled one rather than as a lost race.
-        const local = this.ctx.hasUI ?
-            this.askLocal(spec, ac.signal).catch(() => undefined)
+        const localSide = this.ctx.hasUI ?
+            local(ac.signal).catch(() => undefined)
             : new Promise(() => { });
         try {
             const winner = await Promise.race([
-                local.then(v => ({ from: 'local', v })),
+                localSide.then(v => ({ from: 'local', v })),
                 remote.then(v => ({ from: 'remote', v }))
             ]);
             if (winner.from === 'remote')
@@ -80,6 +139,8 @@ export class SessionUI {
         finally {
             b.pending.delete(id);
             clearPrompt(id);
+            if (displaced && b.pending.has(displaced.id))
+                setPrompt(displaced);
         }
     }
     /**
@@ -141,11 +202,61 @@ export function publishLifecycleNotice(message, level) {
     else
         publishNotify(message, level);
 }
-export function publishViewer(title, text) {
-    getBridge().broadcast({ type: 'viewer', title, text });
+/**
+ * Say it on BOTH surfaces. The local notify is attempted first and its failure
+ * absorbed — a stale ctx must not cost the remote the message, which is the one
+ * surface still there when nobody is at the terminal.
+ */
+export function notifyBoth(ctx, message, level) {
+    try {
+        ctx.ui.notify(message, level);
+    }
+    catch {
+        /* stale ctx — the remote half below is what matters */
+    }
+    publishLifecycleNotice(message, level);
+}
+/** {@link notifyBoth} for something that must outlive a toast — see
+ *  {@link publishRunNotice}. */
+export function notifyRun(ctx, message, level) {
+    try {
+        ctx.ui.notify(message, level);
+    }
+    catch {
+        /* stale ctx — the remote half below is what matters */
+    }
+    publishRunNotice(message, level);
+}
+/**
+ * A run outcome the remote must still have later: what a gate decided, what a
+ * commit failed to do, what a resume refused. Unlike publishLifecycleNotice it
+ * persists at EVERY level, because "still there in the morning" is the reason
+ * these are published at all — a warning that vanishes after four seconds tells
+ * an absent user nothing.
+ */
+export function publishRunNotice(message, level) {
+    if (level === 'error')
+        addError(message);
+    else
+        addSystemNote(message);
+}
+/** Commit text to the remote transcript. Unlike a notify it is in the reconnect
+ *  snapshot, so it is still there after a refresh. */
+export function publishNote(text) {
+    addSystemNote(text);
 }
 // ─── Shimmed ctx ─────────────────────────────────────────────────────────────
 const SHIMMED_MARKER = '__piRemoteShimmed';
+const REMOTE_ORIGIN_MARKER = '__piRemoteOrigin';
+/**
+ * True when this ctx reached the handler through the browser rather than the
+ * terminal. A command that can only draw itself on the host TUI must check it:
+ * awaiting a local overlay for a remote caller parks the browser on a dialog
+ * nobody is sitting in front of.
+ */
+export function isRemoteOrigin(ctx) {
+    return ctx[REMOTE_ORIGIN_MARKER] === true;
+}
 /**
  * Wraps an event-scoped ExtensionContext so it can be used as a command ctx
  * for commands that don't need newSession (e.g. /task-resume, /task-list,
@@ -178,7 +289,12 @@ export function registerBridgeCommand(pi, name, def) {
     const wrapped = {
         ...def,
         handler: (args, ctx) => {
-            b.currentCtx = ctx; // keep latest live ctx for remote dispatch
+            // A remote-dispatched ctx is a clone of this very field. Storing it
+            // back would make the next remote line clone the clone — one more
+            // prototype link per command, for the life of the session — and would
+            // leave the marker on the ctx a later TERMINAL command is handed.
+            if (!isRemoteOrigin(ctx))
+                b.currentCtx = ctx;
             return def.handler(args, ctx);
         }
     };
@@ -242,8 +358,12 @@ export function dispatchRemoteLine(text, opts) {
     // sync throws and async rejections from the (often async) command handler
     // as a toast instead of crashing or becoming an unhandled rejection.
     const toastErr = (err) => publishNotify(`/${name} failed: ${err.message}`, 'error');
+    // A prototype clone rather than the ctx itself: the marker must not leak onto
+    // the shared currentCtx and make the NEXT terminal invocation look remote.
+    const remoteCtx = Object.create(b.currentCtx);
+    remoteCtx[REMOTE_ORIGIN_MARKER] = true;
     try {
-        const result = handler(args, b.currentCtx);
+        const result = handler(args, remoteCtx);
         if (result instanceof Promise)
             result.catch(toastErr);
     }

package/dist/remote/protocol.d.ts

@@ -14,6 +14,14 @@ export interface PromptMessage {
         label: string;
         value: string;
     }[];
+    /**
+     * The card only DISPLAYS. `recommended` carries the body, and the buttons
+     * collapse to a single Close that answers with an empty string. Its one
+     * producer is /task-plan's answer to a question the USER asked, which needs
+     * dismissing rather than answering — and which needs to be a prompt, not a
+     * broadcast-only frame, because only a prompt is in the reconnect snapshot.
+     */
+    dismissOnly?: boolean;
     allowSkip: boolean;
 }
 export interface PromptResolvedMessage {
@@ -58,11 +66,6 @@ export interface HeldMessage {
     /** True while a task run owns the session (drives the composer placeholder). */
     runActive: boolean;
 }
-export interface ViewerMessage {
-    type: 'viewer';
-    title: string;
-    text: string;
-}
 export interface ContextUsage {
     tokens?: number;
     contextWindow?: number;
@@ -87,7 +90,7 @@ export type { SnapshotMessage } from './session-state.js';
 /** Server → browser messages. The live text_delta / tool_* / agent_* /
  *  user_message deltas are emitted by the SessionState mutators
  *  and not all enumerated here; the snapshot below carries the full state. */
-export type ServerMessage = PromptMessage | PromptResolvedMessage | WidgetMessage | NotifyMessage | ViewerMessage | HeldMessage | ContextMessage | ResetMessage | import('./session-state.js').SnapshotMessage;
+export type ServerMessage = PromptMessage | PromptResolvedMessage | WidgetMessage | NotifyMessage | HeldMessage | ContextMessage | ResetMessage | import('./session-state.js').SnapshotMessage;
 /** Browser → server messages. */
 export interface ClientChatMessage {
     type: 'message';

package/dist/remote/register.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../config/config.js';
-import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx, interruptAgent, registerBridgeCommand, registerRemoteOnlyCommand, publishNotify } from './bridge.js';
+import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx, interruptAgent, registerBridgeCommand, registerRemoteOnlyCommand, publishNotify, cancelPendingPrompts, notifyBoth } from './bridge.js';
 import { setupEvents } from './events.js';
 import { reset, addUserTurn, setHeld, getState } from './session-state.js';
 import { html } from './ui.js';
@@ -45,6 +45,12 @@ export function registerRemote(pi) {
             return S.server;
         S.server = await startServer(text => {
             if (text === '/new') {
+                // The reset inside a new session clears the browser's prompt
+                // card, so a parked ask has lost its last surface. Only HERE:
+                // session_start also fires for the /task handoff's own
+                // newSession, and cancelling there reads to the planner as the
+                // user skipping a question they never saw.
+                cancelPendingPrompts();
                 dispatchRemoteNewSession(newCtx => {
                     S.send = (msg, opts) => {
                         void (opts ?
@@ -89,7 +95,7 @@ export function registerRemote(pi) {
         if (getConfig().remote) {
             // Optional feature: a bind failure must never take pi down. Degrade
             // to a one-line warning and keep the agent running without remote.
-            void ensureServer().catch(err => ctx.ui.notify(`Remote UI unavailable: ${err.message}`, 'warning'));
+            void ensureServer().catch(err => notifyBoth(ctx, `Remote UI unavailable: ${err.message}`, 'warning'));
         }
     });
     pi.on('session_shutdown', (event, _ctx) => {
@@ -124,7 +130,7 @@ export function registerRemote(pi) {
         description: 'Show the remote QR code & URLs.',
         handler: async (args, ctx) => {
             if (!getConfig().remote) {
-                ctx.ui.notify('Remote is disabled — enable it in /task-config.', 'info');
+                notifyBoth(ctx, 'Remote is disabled — enable it in /task-config.', 'info');
                 return;
             }
             if (args.trim() === 'stop') {
@@ -134,10 +140,10 @@ export function registerRemote(pi) {
                     S.server = null;
                     S.serveResult = null;
                     void teardownTailscaleServe(port).catch(() => { });
-                    ctx.ui.notify('Remote server stopped', 'info');
+                    notifyBoth(ctx, 'Remote server stopped', 'info');
                 }
                 else {
-                    ctx.ui.notify('Remote server is not running', 'warning');
+                    notifyBoth(ctx, 'Remote server is not running', 'warning');
                 }
                 return;
             }
@@ -193,10 +199,10 @@ export function registerRemote(pi) {
                     })
                         .catch(() => { });
                 }
-                ctx.ui.notify(`Remote running at ${primaryUrl}`, 'info');
+                notifyBoth(ctx, `Remote running at ${primaryUrl}`, 'info');
             }
             catch (err) {
-                ctx.ui.notify(`Remote UI unavailable: ${err.message}`, 'error');
+                notifyBoth(ctx, `Remote UI unavailable: ${err.message}`, 'error');
             }
         }
     });

package/dist/remote/session-state.js

@@ -198,7 +198,12 @@ export function setPrompt(prompt) {
 }
 export function clearPrompt(id) {
     const s = getState();
-    s.prompt = null;
+    // Only the prompt that is actually on screen. Two asks can be live at once —
+    // dispatchRemoteLine starts a command whatever else is running — and the slot
+    // holds one, so clearing unconditionally would drop the survivor out of the
+    // snapshot and leave a reconnecting browser unable to answer it.
+    if (s.prompt?.id === id)
+        s.prompt = null;
     s.sink({ type: 'prompt_resolved', id });
 }
 export function setContext(context) {

package/dist/remote/ui-script.js

@@ -101,9 +101,6 @@ export function clientScript(wsUrl) {
     const promptRecText = document.getElementById('prompt-rec-text');
     const promptInput = document.getElementById('prompt-input');
     const promptButtons = document.getElementById('prompt-buttons');
-    const viewer = document.getElementById('viewer');
-    const viewerBody = document.getElementById('viewer-body');
-    document.getElementById('viewer-close').onclick = function () { viewer.style.display = 'none'; };
     let activePromptId = null;
     let activeRecommended = '';
     let activeRecommended2 = '';
@@ -832,13 +829,16 @@ export function clientScript(wsUrl) {
       return out;
     }
 
-    function renderButtons(buttons, stacked) {
+    // omitCancel is for the dismiss-only card: there is nothing to cancel, and a
+    // Cancel task button beside a read-only answer would offer to abort the run
+    // when the only real choice is to close.
+    function renderButtons(buttons, stacked, omitCancel) {
       promptButtons.className = stacked ? 'row stacked' : 'row';
       promptButtons.innerHTML = '';
       for (let i = 0; i < buttons.length; i++) promptButtons.appendChild(buttons[i]);
       const actions = makeActionBtns();
       for (let i = 0; i < actions.length; i++) promptButtons.appendChild(actions[i]);
-      promptButtons.appendChild(makeCancelBtn());
+      if (!omitCancel) promptButtons.appendChild(makeCancelBtn());
     }
 
     // Manual-entry view: empty textarea + Submit, reachable from the
@@ -881,7 +881,14 @@ export function clientScript(wsUrl) {
       activeRecommended = msg.recommended || '';
       activeRecommended2 = msg.recommended2 || '';
       activeActions = msg.actions || [];
-      if (msg.recommended) {
+      if (msg.dismissOnly) {
+        // Mode C: nothing to answer. The body goes in the panel so it renders as
+        // markdown, and Close is the only way out.
+        promptInput.style.display = 'none';
+        promptRec.style.display = 'block';
+        setContent(promptRecText, msg.recommended || '');
+        renderButtons([makeBtn('Close', 'primary', function () { answer(''); })], false, true);
+      } else if (msg.recommended) {
         // Mode A: recommendation(s) present. Render markdown in the panel so a
         // recommendation with code/emphasis reads the same as an assistant bubble.
         setContent(promptRecText, msg.recommended);
@@ -1086,10 +1093,6 @@ export function clientScript(wsUrl) {
         case 'notify':
           showToast(msg.message, msg.level);
           break;
-        case 'viewer':
-          viewerBody.textContent = msg.text;
-          viewer.style.display = 'block';
-          break;
         case 'reset':
           // A new session started — wipe the previous session's transcript.
           chatLog.innerHTML = '';