@mjasnikovs/pi-task 0.4.4 → 0.6.0

package/dist/remote/bridge.d.ts

@@ -1,5 +1,5 @@
-import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
-import type { PromptMessage, ServerMessage } from './protocol.js';
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent';
+import type { ContextUsage, PromptMessage, ServerMessage } from './protocol.js';
 export interface BridgeState {
     /** promptId → resolver that settles the remote side of an ask() race. */
     pending: Map<string, (value: string | undefined) => void>;
@@ -7,6 +7,8 @@ export interface BridgeState {
     activePrompt: PromptMessage | null;
     /** Last lines pushed per widget key (replayed to late joiners). */
     activeWidgets: Map<string, string[]>;
+    /** Most recent context-window usage (replayed to seed late joiners' bar), or null. */
+    lastContextUsage: ContextUsage | null;
     nextId: number;
     /** Command name → handler, populated as pi-task registers its commands. */
     commands: Map<string, (args: string, ctx: ExtensionCommandContext) => unknown>;
@@ -46,6 +48,19 @@ export declare class SessionUI {
 export declare function publishWidget(key: string, lines: string[] | undefined): void;
 export declare function publishNotify(message: string, level: 'info' | 'warning' | 'error'): void;
 export declare function publishViewer(title: string, text: string): void;
+/**
+ * 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,
+ * /task-cancel, /task-auto-cancel).
+ *
+ * - waitForIdle: polls ctx.isIdle() instead of the real runtime hook.
+ * - newSession: throws a clear error so /task, /task-auto, /task-auto-resume
+ *   show a helpful message rather than a confusing TypeError.
+ *
+ * The shim is replaced by a real ExtensionCommandContext the first time the
+ * user runs any /task* or /remote command in the terminal.
+ */
+export declare function makeShimmedCtx(ctx: ExtensionContext): ExtensionCommandContext;
 interface BridgeCommandDef {
     description: string;
     handler: (args: string, ctx: ExtensionCommandContext) => unknown;
@@ -55,17 +70,8 @@ interface BridgeCommandDef {
  *  can invoke it. Use in place of pi.registerCommand for task commands. */
 export declare function registerBridgeCommand(pi: ExtensionAPI, name: string, def: BridgeCommandDef): void;
 /** Start a new session in response to a remote `/new`. Reads the freshest
- *  command-capable ctx (currentCtx) at call time and mirrors dispatchRemoteLine's
- *  guards: a missing, non-command, or stale ctx toasts instead of crashing.
- *
- *  The crash this prevents: a captured ctx goes stale after a *local* /new (a
- *  replacement we don't initiate, so we never get a withSession to rebind), and
- *  ctx.newSession() then throws *synchronously* from assertActive — a sync throw
- *  that a bare `.catch()` on the result would miss. `rebind` runs as withSession
- *  with the fresh post-replacement ctx. */
-/** The richer context the runtime passes to a `newSession` withSession callback
- *  (it carries sendUserMessage, unlike a plain command ctx). Derived from the
- *  newSession signature since the package root doesn't re-export the type. */
+ *  command-capable ctx (currentCtx) at call time. If only a shimmed ctx is
+ *  available, the newSession shim throws a clear error. */
 type NewSessionOptions = NonNullable<Parameters<ExtensionCommandContext['newSession']>[0]>;
 type ReplacedSessionContext = Parameters<NonNullable<NewSessionOptions['withSession']>>[0];
 export declare function dispatchRemoteNewSession(rebind: (ctx: ReplacedSessionContext) => void): void;

package/dist/remote/bridge.js

@@ -6,6 +6,7 @@ export function getBridge() {
             pending: new Map(),
             activePrompt: null,
             activeWidgets: new Map(),
+            lastContextUsage: null,
             nextId: 0,
             commands: new Map(),
             currentCtx: null,
@@ -97,6 +98,33 @@ export function publishNotify(message, level) {
 export function publishViewer(title, text) {
     getBridge().broadcast({ type: 'viewer', title, text });
 }
+// ─── Shimmed ctx ─────────────────────────────────────────────────────────────
+const SHIMMED_MARKER = '__piRemoteShimmed';
+/**
+ * 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,
+ * /task-cancel, /task-auto-cancel).
+ *
+ * - waitForIdle: polls ctx.isIdle() instead of the real runtime hook.
+ * - newSession: throws a clear error so /task, /task-auto, /task-auto-resume
+ *   show a helpful message rather than a confusing TypeError.
+ *
+ * The shim is replaced by a real ExtensionCommandContext the first time the
+ * user runs any /task* or /remote command in the terminal.
+ */
+export function makeShimmedCtx(ctx) {
+    const shim = Object.create(ctx);
+    shim[SHIMMED_MARKER] = true;
+    shim.waitForIdle = async () => {
+        while (!ctx.isIdle()) {
+            await new Promise(r => setTimeout(r, 100));
+        }
+    };
+    shim.newSession = () => {
+        throw new Error('Run /remote in the terminal once to enable /task, /task-auto, and /new from remote.');
+    };
+    return shim;
+}
 /** Register a command with pi AND record it in the bridge so remote slash lines
  *  can invoke it. Use in place of pi.registerCommand for task commands. */
 export function registerBridgeCommand(pi, name, def) {
@@ -115,13 +143,7 @@ export function dispatchRemoteNewSession(rebind) {
     const b = getBridge();
     const ctx = b.currentCtx;
     if (!ctx) {
-        publishNotify('Start a session before running /new remotely.', 'warning');
-        return;
-    }
-    // A bare event-scoped ctx lacks newSession; a stale command ctx still has it
-    // but throws on call — the try/catch below covers that case.
-    if (typeof ctx.waitForIdle !== 'function') {
-        publishNotify('Session changed locally — run any task command in the terminal once to re-enable remote /new.', 'warning');
+        publishNotify('No session context available — restart pi and try again.', 'warning');
         return;
     }
     const toastErr = (err) => publishNotify(`/new failed: ${err.message}`, 'error');
@@ -158,14 +180,8 @@ export function dispatchRemoteLine(text, opts) {
         return true;
     }
     if (!b.currentCtx) {
-        publishNotify('Start a session before running commands remotely.', 'warning');
-        return true;
-    }
-    // Command handlers need a command-capable ctx (waitForIdle/newSession). A bare
-    // event-scoped ExtensionContext lacks those; if currentCtx is one (e.g. nothing
-    // command-capable has been captured yet), toast instead of throwing a TypeError.
-    if (typeof b.currentCtx.waitForIdle !== 'function') {
-        publishNotify('Session changed locally — run any task command in the terminal once to re-enable remote commands.', 'warning');
+        // Shouldn't happen after session_start seeds a shimmed ctx, but guard anyway.
+        publishNotify(`/${name}: no session context yet — restart pi.`, 'warning');
         return true;
     }
     // Invoke synchronously so the call happens immediately, but surface both

package/dist/remote/events.js

@@ -1,4 +1,5 @@
 import { setAgentIdle } from './state.js';
+import { getBridge } from './bridge.js';
 export function setupEvents(pi, history, broadcastFn) {
     let currentText = '';
     const currentTools = [];
@@ -67,6 +68,8 @@ export function setupEvents(pi, history, broadcastFn) {
     pi.on('agent_end', (_event, ctx) => {
         const contextUsage = ctx.getContextUsage();
         setAgentIdle(true);
+        // Remember it so a browser that connects mid-session gets its bar seeded.
+        getBridge().lastContextUsage = contextUsage;
         history.addAssistantTurn(currentText, [...currentTools]);
         broadcastFn({ type: 'agent_end', contextUsage });
         currentText = '';

package/dist/remote/protocol.d.ts

@@ -24,10 +24,21 @@ export interface ViewerMessage {
     title: string;
     text: string;
 }
+export interface ContextUsage {
+    tokens?: number;
+    contextWindow?: number;
+    percent?: number;
+}
+/** Seeds the context-usage bar for a freshly-connected client (the live value is
+ *  otherwise only carried on agent_end). */
+export interface ContextMessage {
+    type: 'context';
+    contextUsage: ContextUsage;
+}
 /** Server → browser messages added by the integration. The existing
  *  history / text_delta / tool_* / agent_* / client_count / user_message messages are
  *  emitted ad hoc by events.ts / server.ts and are not enumerated here. */
-export type ServerMessage = PromptMessage | PromptResolvedMessage | WidgetMessage | NotifyMessage | ViewerMessage;
+export type ServerMessage = PromptMessage | PromptResolvedMessage | WidgetMessage | NotifyMessage | ViewerMessage | ContextMessage;
 /** Browser → server messages. */
 export interface ClientChatMessage {
     type: 'message';

package/dist/remote/register.js

@@ -1,31 +1,24 @@
 import { broadcast } from './broadcast.js';
-import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession } from './bridge.js';
+import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx } from './bridge.js';
 import { setupEvents } from './events.js';
 import { HistoryBuffer } from './history.js';
 import { html } from './ui.js';
 import { qrLines } from './qr.js';
 import { startServer, formatAddresses } from './server.js';
+import { ensureTailscaleServe, teardownTailscaleServe, planRemoteUrls } from './tailscale.js';
 import { isAgentIdle } from './state.js';
 const _g = globalThis;
 if (!_g.__piRemote)
-    _g.__piRemote = { server: null, send: null };
+    _g.__piRemote = { server: null, send: null, serveResult: null };
 const S = _g.__piRemote;
 export function registerRemote(pi) {
     const history = new HistoryBuffer(20);
-    /** Start the always-on remote server once; later calls return the live handle.
-     *  Plain chat works immediately via S.send; remote slash commands and /new
-     *  bind once any command supplies a command-capable ctx (see dispatchRemoteLine). */
     async function ensureServer() {
         if (S.server)
             return S.server;
         S.server = await startServer(text => {
             if (text === '/new') {
-                // Route through the bridge's freshest command ctx with the same
-                // crash-safe guards as remote slash commands. The withSession
-                // rebind keeps S.send pointed at the new session's ctx.
                 dispatchRemoteNewSession(newCtx => {
-                    // newCtx.sendUserMessage bypasses the stale runtime check
-                    // (returns a Promise we deliberately discard).
                     S.send = (msg, opts) => {
                         void (opts ?
                             newCtx.sendUserMessage(msg, opts)
@@ -34,14 +27,8 @@ export function registerRemote(pi) {
                 });
                 return;
             }
-            // Slash commands route to the bridge's command registry;
-            // plain lines fall through to onPlain and go to the agent.
             dispatchRemoteLine(text, {
                 onPlain: plain => {
-                    // Persist remote-typed messages: they arrive via
-                    // sendUserMessage with source "extension", which the
-                    // interactive input handler skips, so record them
-                    // here for reconnect/history.
                     history.addUserMessage(plain);
                     if (isAgentIdle()) {
                         S.send?.(plain);
@@ -52,28 +39,35 @@ export function registerRemote(pi) {
                 }
             });
         }, wsUrl => html(wsUrl), () => history.getEntries());
+        // Hands-off HTTPS: point Tailscale serve at our port so phones get a
+        // secure context. Best-effort — any failure degrades to the http URL.
+        S.serveResult = await ensureTailscaleServe(S.server.port).catch(() => ({ state: 'unavailable' }));
         return S.server;
     }
     pi.on('session_start', (_event, ctx) => {
-        // Update shared send with fresh pi on each session (survives /new re-evaluation)
         S.send = (text, opts) => (opts ? pi.sendUserMessage(text, opts) : pi.sendUserMessage(text));
         setupEvents(pi, history, broadcast);
-        // Always-on: bring the remote server up automatically so no /remote is
-        // needed. Plain chat flows immediately via S.send; the local widget shows
-        // the reachable URLs. Run /remote to view the QR or fully enable remote
-        // slash commands.
-        // NOTE: we deliberately do NOT seed bridge.currentCtx here. The event ctx
-        // is the base ExtensionContext (no waitForIdle/newSession), so storing it
-        // would make a later remote /task throw. currentCtx is only ever set from
-        // a real command ctx: the /remote handler, registerBridgeCommand, and the
-        // remote-/new withSession rebind. See dispatchRemoteLine's capability guard.
+        // Seed a shimmed ctx so commands that don't need newSession (/task-list,
+        // /task-cancel, /task-auto-cancel) work immediately from the remote without
+        // any terminal interaction. Only overwrite if null or already shimmed —
+        // a real command ctx captured from a prior terminal command must survive
+        // session_start (it's updated via withSession or registerBridgeCommand,
+        // not replaced here).
+        const b = getBridge();
+        if (!b.currentCtx
+            || b.currentCtx['__piRemoteShimmed'] === true) {
+            b.currentCtx = makeShimmedCtx(ctx);
+        }
         void ensureServer().catch(err => ctx.ui.notify(`Failed to start remote: ${err.message}`, 'error'));
     });
     pi.on('session_shutdown', (event, _ctx) => {
         if (event.reason === 'quit') {
             if (S.server) {
+                const port = S.server.port;
                 S.server.stop();
                 S.server = null;
+                S.serveResult = null;
+                void teardownTailscaleServe(port).catch(() => { });
             }
             S.send = null;
         }
@@ -83,8 +77,11 @@ export function registerRemote(pi) {
         handler: async (args, ctx) => {
             if (args.trim() === 'stop') {
                 if (S.server) {
+                    const port = S.server.port;
                     S.server.stop();
                     S.server = null;
+                    S.serveResult = null;
+                    void teardownTailscaleServe(port).catch(() => { });
                     ctx.ui.notify('Remote server stopped', 'info');
                 }
                 else {
@@ -92,26 +89,27 @@ export function registerRemote(pi) {
                 }
                 return;
             }
-            // Capture this command-capable ctx so remote slash commands and /new
-            // work (the always-on auto-start can only bind plain chat).
+            // Upgrade from shimmed ctx to a real command-capable ctx.
             getBridge().currentCtx = ctx;
             try {
                 const server = await ensureServer();
-                // QR keeps encoding only the primary (Tailscale-preferred) URL.
-                const primaryUrl = `http://${server.ip}:${server.port}`;
+                const httpPrimary = `http://${server.ip}:${server.port}`;
+                const result = S.serveResult ?? { state: 'unavailable' };
+                const plan = planRemoteUrls(httpPrimary, result);
+                const primaryUrl = plan.primaryUrl;
                 const qr = await qrLines(primaryUrl);
-                // Labeled, block-aligned address lines: Tailscale + LAN when present.
-                const addrs = formatAddresses(server.ips, server.port);
+                const addrs = [...plan.urlLines, ...formatAddresses(server.ips, server.port)];
                 const labelW = addrs.reduce((m, a) => Math.max(m, a.label.length), 0);
-                const addrLines = addrs.map(a => a.label ? `${a.label.padEnd(labelW)}  ${a.url}` : a.url);
+                const addrLines = [
+                    ...addrs.map(a => (a.label ? `${a.label.padEnd(labelW)}  ${a.url}` : a.url)),
+                    ...plan.hintLines
+                ];
                 const addrWidth = addrLines.reduce((m, l) => Math.max(m, l.length), 0);
                 if (ctx.mode === 'tui') {
                     // eslint-disable-next-line no-control-regex -- strip ANSI SGR escapes to measure visible width
                     const stripAnsi = (s) => s.replace(/\x1b\[[^m]*m/g, '');
                     const visWidth = qr.reduce((max, l) => Math.max(max, stripAnsi(l).length), 0);
                     const overlayWidth = Math.max(visWidth, addrWidth + 4, 36);
-                    // Fire-and-forget: don't await so the command handler returns immediately
-                    // (avoids "Working" lock if user runs /new before dismissing)
                     ctx.ui
                         .custom((_tui, _theme, _kb, done) => ({
                         focused: false,

package/dist/remote/server.js

@@ -95,6 +95,9 @@ export async function startServer(onMessage, getHtml, getHistory) {
         }
         if (bridge.activePrompt)
             sendTo(ws, bridge.activePrompt);
+        if (bridge.lastContextUsage) {
+            sendTo(ws, { type: 'context', contextUsage: bridge.lastContextUsage });
+        }
         broadcast({ type: 'client_count', count: clientCount() });
         ws.on('message', data => {
             let msg;

package/dist/remote/tailscale.d.ts

@@ -0,0 +1,45 @@
+/** Injectable command runner so serve orchestration is unit-testable without a real CLI. */
+export interface Run {
+    (cmd: string, args: string[]): Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+}
+export type ServeResult = {
+    state: 'served';
+    url: string;
+} | {
+    state: 'foreign-conflict';
+    host: string;
+} | {
+    state: 'certs-disabled';
+    host: string;
+} | {
+    state: 'unavailable';
+};
+export interface RemoteUrlPlan {
+    /** URL to encode in the QR and announce; the https one when serve is live. */
+    primaryUrl: string;
+    /** Labeled URL lines to add to the address list (e.g. the HTTPS URL when served). */
+    urlLines: {
+        label: string;
+        url: string;
+    }[];
+    /** Extra lines to print under the URLs (empty when nothing to suggest). */
+    hintLines: string[];
+}
+/** The "/" proxy target of the first :443 Web handler in `tailscale serve status --json`,
+ *  or undefined when there is no such handler / the output isn't valid serve JSON
+ *  (e.g. the literal "No serve config"). */
+export declare function serve443Target(json: string): string | undefined;
+/** Ensure Tailscale serves https://<host> → http://127.0.0.1:<port>. Mutates only
+ *  when needed and never touches a serve config we didn't create. Best-effort:
+ *  returns a non-served state rather than throwing. */
+export declare function ensureTailscaleServe(port: number, run?: Run): Promise<ServeResult>;
+/** Tear down the :443 serve handler ONLY if it currently points at our port.
+ *  Best-effort; callers should additionally `.catch()` since it may run during
+ *  shutdown. */
+export declare function teardownTailscaleServe(port: number, run?: Run): Promise<void>;
+/** Pure: pick the primary URL and any hint lines from a serve result. */
+export declare function planRemoteUrls(httpPrimary: string, result: ServeResult): RemoteUrlPlan;

package/dist/remote/tailscale.js

@@ -0,0 +1,108 @@
+import { execFile } from 'node:child_process';
+const defaultRun = (cmd, args) => new Promise(resolve => {
+    execFile(cmd, args, { timeout: 5000 }, (err, stdout, stderr) => {
+        const exitCode = err && typeof err.code === 'number' ?
+            err.code
+            : err ? 1
+                : 0;
+        resolve({ stdout: stdout ?? '', stderr: stderr ?? '', exitCode });
+    });
+});
+/** The "/" proxy target of the first :443 Web handler in `tailscale serve status --json`,
+ *  or undefined when there is no such handler / the output isn't valid serve JSON
+ *  (e.g. the literal "No serve config"). */
+export function serve443Target(json) {
+    let parsed;
+    try {
+        parsed = JSON.parse(json);
+    }
+    catch {
+        return undefined;
+    }
+    const web = parsed
+        .Web;
+    if (!web)
+        return undefined;
+    for (const key of Object.keys(web)) {
+        if (key.endsWith(':443'))
+            return web[key]?.Handlers?.['/']?.Proxy;
+    }
+    return undefined;
+}
+/** Tailscale MagicDNS name (trailing dot stripped), or undefined if the daemon
+ *  isn't reachable / has no name. */
+async function tailscaleHost(run) {
+    const status = await run('tailscale', ['status', '--json']);
+    if (status.exitCode !== 0)
+        return undefined;
+    try {
+        const parsed = JSON.parse(status.stdout);
+        return (parsed.Self?.DNSName ?? '').replace(/\.$/, '') || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Ensure Tailscale serves https://<host> → http://127.0.0.1:<port>. Mutates only
+ *  when needed and never touches a serve config we didn't create. Best-effort:
+ *  returns a non-served state rather than throwing. */
+export async function ensureTailscaleServe(port, run = defaultRun) {
+    const host = await tailscaleHost(run);
+    if (!host)
+        return { state: 'unavailable' };
+    const ours = `http://127.0.0.1:${port}`;
+    const serve = await run('tailscale', ['serve', 'status', '--json']);
+    const target = serve443Target(serve.stdout);
+    if (target === ours)
+        return { state: 'served', url: `https://${host}` };
+    if (target !== undefined)
+        return { state: 'foreign-conflict', host };
+    // No :443 handler yet — check cert capability before trying to create one.
+    const cert = await run('tailscale', ['cert']);
+    if (/HTTPS cert support is not enabled/i.test(cert.stdout + cert.stderr)) {
+        return { state: 'certs-disabled', host };
+    }
+    const set = await run('tailscale', ['serve', '--bg', '--https=443', ours]);
+    if (set.exitCode === 0)
+        return { state: 'served', url: `https://${host}` };
+    return { state: 'certs-disabled', host };
+}
+/** Tear down the :443 serve handler ONLY if it currently points at our port.
+ *  Best-effort; callers should additionally `.catch()` since it may run during
+ *  shutdown. */
+export async function teardownTailscaleServe(port, run = defaultRun) {
+    const serve = await run('tailscale', ['serve', 'status', '--json']);
+    if (serve443Target(serve.stdout) === `http://127.0.0.1:${port}`) {
+        await run('tailscale', ['serve', '--https=443', 'off']);
+    }
+}
+/** Pure: pick the primary URL and any hint lines from a serve result. */
+export function planRemoteUrls(httpPrimary, result) {
+    switch (result.state) {
+        case 'served':
+            return {
+                primaryUrl: result.url,
+                urlLines: [{ label: 'HTTPS', url: result.url }],
+                hintLines: []
+            };
+        case 'foreign-conflict':
+            return {
+                primaryUrl: httpPrimary,
+                urlLines: [],
+                hintLines: [
+                    'HTTPS: port 443 is already used by another tailscale serve config; not touching it.',
+                    '  Free it (tailscale serve --https=443 off) to enable phone notifications.'
+                ]
+            };
+        case 'certs-disabled':
+            return {
+                primaryUrl: httpPrimary,
+                urlLines: [],
+                hintLines: [
+                    'HTTPS (for phone notifications): enable HTTPS in the Tailscale admin console, then restart the remote.'
+                ]
+            };
+        case 'unavailable':
+            return { primaryUrl: httpPrimary, urlLines: [], hintLines: [] };
+    }
+}

package/dist/remote/ui.js

@@ -5,8 +5,8 @@ export function html(wsUrl) {
         + `text-anchor="middle" fill="#cba6f7">π</text></svg>`);
     const iconUrl = `data:image/svg+xml,${iconSvg}`;
     const manifest = encodeURIComponent(JSON.stringify({
-        name: 'pi remote',
-        short_name: 'pi remote',
+        name: 'pi-task remote',
+        short_name: 'pi-task remote',
         display: 'standalone',
         background_color: '#1e1e2e',
         theme_color: '#1e1e2e',
@@ -19,11 +19,11 @@ export function html(wsUrl) {
   <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no, viewport-fit=cover">
   <meta name="apple-mobile-web-app-capable" content="yes">
   <meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">
-  <meta name="apple-mobile-web-app-title" content="pi remote">
+  <meta name="apple-mobile-web-app-title" content="pi-task remote">
   <meta name="theme-color" content="#1e1e2e">
   <link rel="apple-touch-icon" href="${iconUrl}">
   <link rel="manifest" href="data:application/manifest+json,${manifest}">
-  <title>pi remote</title>
+  <title>pi-task remote</title>
   <style>
     :root {
       --base: #1e1e2e; --mantle: #181825; --crust: #11111b;
@@ -38,7 +38,7 @@ export function html(wsUrl) {
       font-family: ui-monospace, monospace; height: 100dvh;
       display: flex; flex-direction: column; overflow: hidden;
       padding: env(safe-area-inset-top, 0px) env(safe-area-inset-right, 0px)
-               env(safe-area-inset-bottom, 0px) env(safe-area-inset-left, 0px);
+               0px env(safe-area-inset-left, 0px);
     }
     #context-bar { height: 4px; background: var(--surface0); flex-shrink: 0; }
     #context-bar-fill { height: 100%; background: var(--mauve); width: 0%; transition: width 0.4s ease; }
@@ -47,10 +47,29 @@ export function html(wsUrl) {
       display: flex; justify-content: space-between; align-items: center;
       font-size: 13px; flex-shrink: 0; border-bottom: 1px solid var(--surface0);
     }
-    #header .title { font-weight: bold; color: var(--mauve); letter-spacing: 0.05em; }
-    #header .status { color: var(--subtext0); font-size: 11px; }
+    #header .title { font-weight: bold; color: var(--mauve); letter-spacing: 0.05em;
+      position: relative; animation: glitch 5s steps(1) infinite; }
+    @keyframes glitch {
+      0%, 88%, 100% { text-shadow: none; transform: translate(0, 0); }
+      90% { text-shadow: -1px 0 var(--red), 1px 0 var(--teal); transform: translate(1px, -1px); }
+      92% { text-shadow: 1px 0 var(--red), -1px 0 var(--blue); transform: translate(-1px, 1px); }
+      94% { text-shadow: -1px 0 var(--blue), 1px 0 var(--red); transform: translate(1px, 0); }
+      96% { text-shadow: 1px 0 var(--teal), -1px 0 var(--red); transform: translate(-1px, 0); }
+    }
+    @media (prefers-reduced-motion: reduce) { #header .title { animation: none; } }
+    #header .status { color: var(--subtext0); font-size: 11px; display: inline-flex; align-items: center; gap: 5px; }
+    #header .cdot { color: var(--yellow); }
+    #header .cdot.up { color: var(--green); }
+    #header .cdot.down { color: var(--red); }
+    #header .hgroup { display: flex; align-items: center; gap: 10px; }
+    #bell {
+      background: none; border: none; color: var(--subtext1); cursor: pointer;
+      font-size: 15px; line-height: 1; padding: 2px; font-family: inherit;
+    }
+    #bell:hover { color: var(--text); }
+    #bell.on { color: var(--mauve); }
     #chat-log {
-      flex: 1; overflow-y: auto; padding: 16px;
+      flex: 1; min-width: 0; overflow-y: auto; overflow-x: hidden; padding: 16px;
       display: flex; flex-direction: column; gap: 8px;
     }
     #chat-log::-webkit-scrollbar { width: 6px; }
@@ -67,17 +86,11 @@ export function html(wsUrl) {
       max-width: 100%; border: 1px solid var(--red); font-size: 12px;
     }
     .bubble.thinking {
-      display: flex; gap: 5px; align-items: center; padding: 12px 14px;
+      display: flex; gap: 5px; align-items: center; padding: 10px 14px;
     }
-    .bubble.thinking .dot {
-      width: 7px; height: 7px; border-radius: 50%; background: var(--subtext0);
-      animation: thinking-bounce 1.2s infinite ease-in-out both;
-    }
-    .bubble.thinking .dot:nth-child(1) { animation-delay: -0.24s; }
-    .bubble.thinking .dot:nth-child(2) { animation-delay: -0.12s; }
-    @keyframes thinking-bounce {
-      0%, 80%, 100% { transform: scale(0.6); opacity: 0.4; }
-      40% { transform: scale(1); opacity: 1; }
+    .bubble.thinking .spinner {
+      color: var(--mauve); font-size: 15px; line-height: 1;
+      font-family: ui-monospace, monospace;
     }
     .tool-call {
       background: var(--crust); border-radius: 6px; align-self: flex-start;
@@ -86,15 +99,17 @@ export function html(wsUrl) {
     .tool-call summary {
       padding: 6px 10px; color: var(--subtext1); cursor: pointer;
       user-select: none; list-style: none;
+      overflow-wrap: anywhere; word-break: break-word;
     }
     .tool-call summary::-webkit-details-marker { display: none; }
     .tool-call summary::before { content: "▶  "; }
     .tool-call[open] > summary::before { content: "▼  "; }
     .tool-call.error > summary { color: var(--red); }
     .tool-call pre {
-      padding: 8px 12px; overflow-x: auto; overflow-y: auto;
+      padding: 8px 12px; overflow-y: auto;
       color: var(--subtext1); font-size: 11px; max-height: 280px;
       border-top: 1px solid var(--surface0);
+      white-space: pre-wrap; overflow-wrap: anywhere; word-break: break-word;
     }
     .code-block {
       background: var(--crust); border: 1px solid var(--surface0);
@@ -115,7 +130,7 @@ export function html(wsUrl) {
     .hl-num { color: var(--blue); }
     .hl-fn  { color: var(--yellow); }
     #input-bar {
-      background: var(--mantle); padding: 10px 16px;
+      background: var(--mantle); padding: 10px 16px calc(10px + env(safe-area-inset-bottom, 0px));
       display: flex; gap: 8px; flex-shrink: 0;
       border-top: 1px solid var(--surface0);
       position: relative;
@@ -165,26 +180,53 @@ export function html(wsUrl) {
     #status-panel { padding: 6px 12px; border-bottom: 1px solid var(--surface1);
       color: var(--subtext1); white-space: pre-wrap; font-size: 13px; display: none; }
     #prompt-card { position: fixed; left: 0; right: 0; bottom: 0; background: var(--mantle);
-      border-top: 2px solid var(--mauve); padding: 14px; display: none; z-index: 50; }
-    #prompt-card .q { color: var(--text); margin-bottom: 8px; white-space: pre-wrap; }
+      border-top: 2px solid var(--mauve); padding: 16px 14px calc(16px + env(safe-area-inset-bottom, 0px));
+      display: none; z-index: 50; max-height: 80dvh; overflow-y: auto; }
+    #prompt-card .q-label { color: var(--mauve); font-size: 11px; font-weight: 700;
+      text-transform: uppercase; letter-spacing: .6px; margin-bottom: 6px; }
+    #prompt-card .q { color: var(--text); margin-bottom: 12px; white-space: pre-wrap;
+      font-size: 15px; line-height: 1.5; }
+    #prompt-card .rec-panel { background: var(--surface0); border-left: 3px solid var(--green);
+      border-radius: 6px; padding: 10px 12px; margin-bottom: 12px; }
+    #prompt-card .rec-label { color: var(--green); font-size: 11px; font-weight: 700;
+      text-transform: uppercase; letter-spacing: .5px; margin-bottom: 4px; }
+    #prompt-card .rec-text { color: var(--text); font-size: 15px; line-height: 1.5;
+      white-space: pre-wrap; overflow-wrap: anywhere; }
     #prompt-card textarea { width: 100%; background: var(--surface0); color: var(--text);
-      border: 1px solid var(--surface2); border-radius: 6px; padding: 8px; }
-    #prompt-card .row { display: flex; gap: 8px; margin-top: 8px; }
-    #prompt-card button { padding: 6px 12px; border-radius: 6px; border: none; cursor: pointer; }
-    .toast { position: fixed; top: 12px; right: 12px; padding: 8px 12px; border-radius: 6px;
+      border: 1px solid var(--surface2); border-radius: 6px; padding: 10px; font-size: 15px;
+      font-family: inherit; line-height: 1.5; resize: vertical; margin-bottom: 4px; }
+    #prompt-card .row { display: flex; gap: 8px; margin-top: 12px; align-items: center;
+      flex-wrap: wrap; }
+    #prompt-card button { padding: 11px 16px; border-radius: 8px; border: none; cursor: pointer;
+      font-family: inherit; font-size: 14px; font-weight: 600; transition: filter .15s ease; }
+    #prompt-card button:hover { filter: brightness(1.08); }
+    #prompt-card button.primary { background: var(--green); color: var(--crust);
+      font-weight: 700; flex: 1; min-width: 160px; }
+    #prompt-card button.secondary { background: var(--surface1); color: var(--text);
+      flex: 1; min-width: 160px; }
+    #prompt-card button.cancel { margin-left: auto; background: transparent; color: var(--subtext0);
+      font-size: 12px; font-weight: 500; padding: 8px 10px; }
+    #prompt-card button.cancel:hover { color: var(--red); filter: none; }
+    #prompt-card button.cancel.armed { background: var(--red); color: var(--crust); font-weight: 700; }
+    .toast { position: fixed; top: 12px; right: 12px; max-width: calc(100vw - 24px);
+      padding: 8px 12px; border-radius: 6px; overflow-wrap: anywhere; word-break: break-word;
       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; display: none; z-index: 70; }
+      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); }
   </style>
 </head>
 <body>
   <div id="context-bar"><div id="context-bar-fill"></div></div>
   <div id="header">
-    <span class="title">pi remote</span>
-    <span class="status" id="client-status">connecting…</span>
+    <span class="title">pi-task remote</span>
+    <div class="hgroup">
+      <span class="status" id="client-status"><span class="cdot" id="conn-dot">&#x25CB;</span><span id="client-label">connecting&#x2026;</span></span>
+      <button id="bell" aria-label="Toggle notifications" title="Notifications">&#x25EF;</button>
+    </div>
   </div>
   <div id="chat-log"></div>
   <div id="status-panel"></div>
@@ -195,8 +237,13 @@ export function html(wsUrl) {
   </div>
   <div id="reconnect-overlay"><span id="reconnect-msg">reconnecting…</span></div>
   <div id="prompt-card">
+    <div class="q-label">pi needs your input</div>
     <div class="q" id="prompt-q"></div>
-    <textarea id="prompt-input" rows="2"></textarea>
+    <div class="rec-panel" id="prompt-rec" style="display:none">
+      <div class="rec-label">Recommended answer</div>
+      <div class="rec-text" id="prompt-rec-text"></div>
+    </div>
+    <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>
@@ -213,19 +260,33 @@ export function html(wsUrl) {
     const inputEl = document.getElementById('input');
     const sendBtn = document.getElementById('send');
     const contextFill = document.getElementById('context-bar-fill');
-    const clientStatus = document.getElementById('client-status');
+    function setContextBar(usage) {
+      if (usage && usage.percent != null) contextFill.style.width = usage.percent + '%';
+    }
+    const connDot = document.getElementById('conn-dot');
+    const clientLabel = document.getElementById('client-label');
+    // state: 'connecting' (○ yellow) | 'up' (● green) | 'down' (● red)
+    function setConn(state, label) {
+      connDot.textContent = state === 'connecting' ? '\\u25CB' : '\\u25CF';
+      connDot.className = 'cdot' + (state === 'up' ? ' up' : state === 'down' ? ' down' : '');
+      if (label !== undefined) clientLabel.textContent = label;
+    }
     const reconnectOverlay = document.getElementById('reconnect-overlay');
     const reconnectMsg = document.getElementById('reconnect-msg');
     const cmdSuggestions = document.getElementById('cmd-suggestions');
     const statusPanel = document.getElementById('status-panel');
     const promptCard = document.getElementById('prompt-card');
     const promptQ = document.getElementById('prompt-q');
+    const promptRec = document.getElementById('prompt-rec');
+    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 cancelArmTimer = null;
     const toolCallMap = {};
     let currentBubble = null;
     let streamText = '';
@@ -411,16 +472,28 @@ export function html(wsUrl) {
     }
 
     let thinkingEl = null;
+    let spinTimer = null;
+    let spinIdx = 0;
+    const SPIN = '\\u280B\\u2819\\u2839\\u2838\\u283C\\u2834\\u2826\\u2827\\u2807\\u280F';
     function showThinking() {
       if (!thinkingEl) {
         thinkingEl = document.createElement('div');
         thinkingEl.className = 'bubble assistant thinking';
-        thinkingEl.innerHTML = '<span class="dot"></span><span class="dot"></span><span class="dot"></span>';
+        thinkingEl.innerHTML = '<span class="spinner"></span>';
+      }
+      if (!spinTimer) {
+        var sp = thinkingEl.firstChild;
+        sp.textContent = SPIN[spinIdx % SPIN.length];
+        spinTimer = setInterval(function () {
+          spinIdx = (spinIdx + 1) % SPIN.length;
+          sp.textContent = SPIN[spinIdx];
+        }, 90);
       }
       chatLog.appendChild(thinkingEl); // append (or move) to bottom
       scrollBottom();
     }
     function hideThinking() {
+      if (spinTimer) { clearInterval(spinTimer); spinTimer = null; }
       if (thinkingEl) thinkingEl.remove();
     }
 
@@ -450,6 +523,61 @@ export function html(wsUrl) {
       setTimeout(function () { t.remove(); }, 4000);
     }
 
+    const bell = document.getElementById('bell');
+    const NOTIFY_KEY = 'piRemoteNotify';
+
+    function notifyEnabled() {
+      return localStorage.getItem(NOTIFY_KEY) === '1'
+        && typeof Notification !== 'undefined'
+        && Notification.permission === 'granted';
+    }
+
+    function updateBell() {
+      // ◉ (mauve) when armed, ◯ (dim) when off/unavailable.
+      var on = notifyEnabled();
+      bell.textContent = on ? '\\u25C9' : '\\u25EF';
+      bell.classList.toggle('on', on);
+    }
+
+    // Why notifications can't be enabled here, or null if they can.
+    function notifyEnvIssue() {
+      if (typeof Notification === 'undefined') return "This browser doesn't support notifications.";
+      if (!window.isSecureContext) return 'Notifications need HTTPS. Open the Tailscale https:// URL, or open via localhost.';
+      const isIOS = /iP(hone|ad|od)/i.test(navigator.userAgent);
+      const standalone = navigator.standalone === true
+        || (window.matchMedia && window.matchMedia('(display-mode: standalone)').matches);
+      if (isIOS && !standalone) return 'On iOS: Share \\u2192 Add to Home Screen first, then enable notifications.';
+      return null;
+    }
+
+    bell.addEventListener('click', function () {
+      // Turning OFF always works regardless of environment.
+      if (localStorage.getItem(NOTIFY_KEY) === '1') {
+        localStorage.setItem(NOTIFY_KEY, '0'); updateBell(); return;
+      }
+      const issue = notifyEnvIssue();
+      if (issue) { showToast(issue, 'warning'); return; }
+      Notification.requestPermission().then(function (perm) {
+        if (perm === 'granted') { localStorage.setItem(NOTIFY_KEY, '1'); }
+        else { showToast('Notifications blocked in browser settings.', 'warning'); }
+        updateBell();
+      });
+    });
+
+    // Fire a browser notification, but only when armed, in a secure context,
+    // and the tab is backgrounded (foreground already has the in-page UI).
+    function notify(title, body, tag) {
+      if (!notifyEnabled()) return;
+      if (!window.isSecureContext) return;
+      if (!document.hidden) return;
+      try {
+        const n = new Notification(title, { body: body || '', tag: tag });
+        n.onclick = function () { window.focus(); n.close(); };
+      } catch (e) { /* constructor unsupported (e.g. iOS without SW) */ }
+    }
+
+    updateBell();
+
     function answer(value) {
       if (activePromptId === null) return;
       ws.send(JSON.stringify({ type: 'prompt_answer', id: activePromptId, value: value }));
@@ -460,33 +588,93 @@ export function html(wsUrl) {
       activePromptId = null;
       promptCard.style.display = 'none';
       promptInput.value = '';
+      promptInput.style.display = 'none';
+      promptRec.style.display = 'none';
+      if (cancelArmTimer) { clearTimeout(cancelArmTimer); cancelArmTimer = null; }
       setEnabled(true);
     }
 
-    function makeBtn(label, bg, onClick) {
+    function makeBtn(label, cls, onClick) {
       const btn = document.createElement('button');
       btn.textContent = label;
-      btn.style.background = bg;
+      if (cls) btn.className = cls;
       btn.onclick = onClick;
       return btn;
     }
 
+    // "Cancel task" aborts the whole run, so it's deliberately small and needs a
+    // two-step confirm: first tap arms it, second tap (within 3s) confirms.
+    function makeCancelBtn() {
+      const btn = makeBtn('Cancel task', 'cancel', null);
+      let armed = false;
+      btn.onclick = function () {
+        if (armed) { answer(undefined); return; }
+        armed = true;
+        btn.classList.add('armed');
+        btn.textContent = 'Tap again to cancel';
+        if (cancelArmTimer) clearTimeout(cancelArmTimer);
+        cancelArmTimer = setTimeout(function () {
+          armed = false;
+          btn.classList.remove('armed');
+          btn.textContent = 'Cancel task';
+          cancelArmTimer = null;
+        }, 3000);
+      };
+      return btn;
+    }
+
+    function renderButtons(buttons) {
+      promptButtons.innerHTML = '';
+      for (let i = 0; i < buttons.length; i++) promptButtons.appendChild(buttons[i]);
+      promptButtons.appendChild(makeCancelBtn());
+    }
+
+    // Manual-entry view: editable textarea + Submit, reachable from the
+    // recommendation view via "Answer manually".
+    function showManualEntry(prefill) {
+      promptRec.style.display = 'none';
+      promptInput.style.display = 'block';
+      promptInput.value = prefill || '';
+      renderButtons([
+        makeBtn('Submit answer', 'primary', function () { answer(promptInput.value); }),
+        makeBtn('← Back', 'secondary', function () { showRecommendation(); })
+      ]);
+      promptInput.focus();
+    }
+
+    // Recommendation view (Mode A): show the suggested answer and let the user
+    // accept it in one tap or switch to manual entry.
+    function showRecommendation() {
+      promptInput.style.display = 'none';
+      promptRec.style.display = 'block';
+      renderButtons([
+        makeBtn('✓ Accept recommended', 'primary', function () { answer(''); }),
+        makeBtn('✎ Answer manually', 'secondary', function () { showManualEntry(activeRecommended); })
+      ]);
+    }
+
     function showPrompt(msg) {
       activePromptId = msg.id;
       promptQ.textContent = msg.question;
-      promptInput.value = msg.recommended || '';
-      promptButtons.innerHTML = '';
-      promptButtons.appendChild(makeBtn('Submit', 'var(--green)', function () { answer(promptInput.value); }));
+      activeRecommended = msg.recommended || '';
       if (msg.recommended) {
-        promptButtons.appendChild(makeBtn('Accept', 'var(--blue)', function () { answer(''); }));
-      }
-      if (msg.allowSkip) {
-        promptButtons.appendChild(makeBtn('Skip', 'var(--surface2)', function () { answer(''); }));
+        // Mode A: there's a recommendation — lead with "Accept recommended".
+        promptRecText.textContent = msg.recommended;
+        showRecommendation();
+      } else {
+        // Mode B: no recommendation — the user must type an answer (or skip).
+        promptRec.style.display = 'none';
+        promptInput.style.display = 'block';
+        promptInput.value = '';
+        const buttons = [makeBtn('Submit answer', 'primary', function () { answer(promptInput.value); })];
+        if (msg.allowSkip) {
+          buttons.push(makeBtn('Skip question', 'secondary', function () { answer(''); }));
+        }
+        renderButtons(buttons);
+        promptInput.focus();
       }
-      promptButtons.appendChild(makeBtn('Cancel task', 'var(--red)', function () { answer(undefined); }));
       promptCard.style.display = 'block';
       setEnabled(false);
-      promptInput.focus();
     }
 
     function handleMsg(msg) {
@@ -570,6 +758,7 @@ export function html(wsUrl) {
             streamText = '';
           }
           addBubble('error', msg.message || 'Error');
+          notify('Agent error', msg.message || 'Error', 'pi-error');
           setEnabled(true);
           break;
         case 'agent_end':
@@ -577,15 +766,19 @@ export function html(wsUrl) {
           currentBubble = null;
           streamText = '';
           setEnabled(true);
-          if (msg.contextUsage && msg.contextUsage.percent != null) {
-            contextFill.style.width = msg.contextUsage.percent + '%';
-          }
+          notify('Task finished', '', 'pi-end');
+          setContextBar(msg.contextUsage);
+          break;
+        case 'context':
+          // Seeds the bar for a client that joined mid-session.
+          setContextBar(msg.contextUsage);
           break;
         case 'client_count':
-          clientStatus.textContent = msg.count + ' client' + (msg.count === 1 ? '' : 's') + ' connected';
+          setConn('up', msg.count + ' client' + (msg.count === 1 ? '' : 's') + ' connected');
           break;
         case 'prompt':
           showPrompt(msg);
+          notify('pi needs your input', msg.question, 'pi-prompt');
           break;
         case 'prompt_resolved':
           if (activePromptId === msg.id) closePrompt();
@@ -646,7 +839,7 @@ export function html(wsUrl) {
       ws.addEventListener('open', () => {
         reconnectOverlay.classList.remove('visible');
         reconnectDelay = 1000;
-        clientStatus.textContent = 'connected';
+        setConn('up', 'connected');
         setEnabled(true);
       });
       ws.addEventListener('message', (e) => {
@@ -654,6 +847,7 @@ export function html(wsUrl) {
       });
       ws.addEventListener('close', () => {
         setEnabled(false);
+        setConn('down', 'disconnected');
         reconnectOverlay.classList.add('visible');
         reconnectMsg.textContent = 'reconnecting in ' + (reconnectDelay / 1000) + 's…';
         setTimeout(() => { reconnectDelay = Math.min(reconnectDelay * 2, 30000); connect(); }, reconnectDelay);

package/dist/shared/child-process.js

@@ -59,15 +59,7 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
                 drainJsonEvents(lineBuffer + '\n', opts);
                 lineBuffer = '';
             }
-            let text;
-            if (isJsonEvents) {
-                const extracted = (finalText || textDeltaAccum).trim();
-                // When json-events mode extracts no text but stderr has content,
-                // surface the stderr as the text so the caller sees the real error
-                // instead of the generic "X child produced no output". Without this,
-                // a model API crash that exits 0 with an error on stderr is invisible.
-                text = extracted.length > 0 ? extracted : (stderr.trim() || undefined);
-            }
+            const text = isJsonEvents ? (finalText || textDeltaAccum).trim() : undefined;
             resolve({ stdout, stderr, exitCode: code ?? 0, aborted, text });
         });
         proc.on('error', () => {

package/dist/task/orchestrator.d.ts

@@ -49,12 +49,19 @@ export declare class TaskRunner {
     cancel(): void;
     /** Execute the full task lifecycle. */
     run(): Promise<void>;
+    /** Stop the phase widget — clearing both the terminal and remote surfaces —
+     *  exactly once. Nulling the disposer makes repeat calls no-ops, so the
+     *  failure flash that handleFailure sets after the catch isn't wiped by the
+     *  finally block's call. */
+    private _disposeWidget;
     private _deliverSpec;
 }
 export interface RunSingleTaskOptions {
     /** Await the session going idle after the spec is delivered, so the caller
      *  blocks until the agent has implemented it. Default false. */
     waitForImplementation?: boolean;
+    /** Resume an existing task by ID instead of starting a new one. */
+    resumeId?: string;
     /** Test seam: spawn function forwarded to TaskRunner. */
     spawnFn?: SpawnFn;
 }

package/dist/task/orchestrator.js

@@ -20,8 +20,8 @@ import * as path from 'node:path';
 import { PHASES, postCommitPhase } from './phases.js';
 import { handleFailure } from './failure-classifier.js';
 import { PHASE_INDEX, PHASE_ORDER, allocateTaskId, ensureTasksDir, normaliseTaskId, parseFrontMatter, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile, extractSection, RESUMABLE_STATES } from './task-file.js';
-import { startWidget, WIDGET_KEY } from './widget.js';
-import { publishViewer, publishNotify, registerBridgeCommand } from '../remote/bridge.js';
+import { startWidget } from './widget.js';
+import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
 import { parseVerifyBlock } from './parsers.js';
 import { formatTimings } from './timings.js';
 // ─── Module-level state ──────────────────────────────────────────────────────
@@ -211,19 +211,13 @@ export class TaskRunner {
             if (parseVerifyBlock(this._pc.spec) === null)
                 throw new Error('no_verify_block');
             await updateTaskFrontMatter(cwd, id, { state: 'completed', phase: 'done' });
-            this._stopWidget?.();
-            try {
-                ctx.ui.setWidget(WIDGET_KEY, undefined);
-            }
-            catch {
-                /* stale ctx */
-            }
+            this._disposeWidget();
             await setTaskSection(cwd, id, 'phase timings', formatTimings(this._timings));
             await setTaskSection(cwd, id, 'handoff', `handoff_at: ${new Date().toISOString()}`);
             await this._deliverSpec(ctx);
         }
         catch (err) {
-            this._stopWidget?.();
+            this._disposeWidget();
             // Persist whatever timings we collected so failed runs are still
             // useful for analysis. Best-effort — never mask the original error.
             if (this._timings.length > 0) {
@@ -237,10 +231,18 @@ export class TaskRunner {
             await handleFailure(err, ctx, cwd, id, this._abort.signal.aborted);
         }
         finally {
-            this._stopWidget?.();
+            this._disposeWidget();
             clearActiveTask(this);
         }
     }
+    /** Stop the phase widget — clearing both the terminal and remote surfaces —
+     *  exactly once. Nulling the disposer makes repeat calls no-ops, so the
+     *  failure flash that handleFailure sets after the catch isn't wiped by the
+     *  finally block's call. */
+    _disposeWidget() {
+        this._stopWidget?.();
+        this._stopWidget = null;
+    }
     async _deliverSpec(ctx) {
         if (this._sendSpec) {
             await this._sendSpec(this._pc.spec);
@@ -272,7 +274,8 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
     const result = await ctx.newSession({
         withSession: async (newCtx) => {
             freshCtx = newCtx;
-            const runner = new TaskRunner(newCtx, cwd, rawPrompt, undefined, async (spec) => {
+            getBridge().currentCtx = newCtx; // keep remote dispatch ctx fresh across session replacement
+            const runner = new TaskRunner(newCtx, cwd, rawPrompt, opts.resumeId, async (spec) => {
                 await newCtx.sendUserMessage(spec);
                 if (opts.waitForImplementation)
                     await newCtx.waitForIdle();
@@ -390,8 +393,10 @@ async function handleTaskResume(args, ctx) {
         }
         id = candidates[0].id;
     }
-    const runner = new TaskRunner(ctx, cwd, '', id);
-    await runner.run();
+    const { sessionCancelled } = await runSingleTask(ctx, cwd, '', { resumeId: id });
+    if (sessionCancelled) {
+        ctx.ui.notify('Could not start a fresh session for /task-resume.', 'warning');
+    }
 }
 // eslint-disable-next-line @typescript-eslint/require-await
 async function handleTaskCancel(_args, ctx) {

package/dist/task/phases.js

@@ -177,23 +177,25 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
     //     is gone, but 4 concurrent streams still split the one GPU and slow
     //     each other ~4x (context worker measured 27s solo vs 128s under load),
     //     so summed-but-fast (~100s) beats max-of-slowed (~130s).
+    // Every worker runs /no_think (below), so sequential is the faster regime.
     // Do NOT switch this back to Promise.all without re-running that A/B.
     //
-    // NOTE: `/no_think` is intentionally NOT applied to research workers.
-    // Several local reasoning models (Qwen3.6, DeepSeek-R1) ignore the
-    // directive — they still emit thinking but the confused stopping logic
-    // causes them to burn their entire output budget on tool calls without
-    // producing text. Letting the model think freely produces proper output.
-    // Result order (files, apis, context, tooling) is preserved for assembly.
+    // `/no_think` is the big win: these are agentic exploration loops, and on a
+    // reasoning model the child would otherwise emit a full <think> trace at
+    // every tool step ("let me read X next…") — the single largest decode sink
+    // in the pipeline. Stripping it cut each worker's decode 3-8x in the A/B.
+    // The worker still calls as many tools as it wants; it just stops narrating
+    // between them. See appendNoThink. Result order (files, apis, context,
+    // tooling) is preserved for assembly.
     const workerSpecs = [
         {
             label: 'worker:files',
-            prompt: promptHeader + RESEARCH_FILES_PROMPT(refined)
+            prompt: appendNoThink(promptHeader + RESEARCH_FILES_PROMPT(refined))
         },
-        { label: 'worker:apis', prompt: promptHeader + RESEARCH_APIS_PROMPT(refined) },
+        { label: 'worker:apis', prompt: appendNoThink(promptHeader + RESEARCH_APIS_PROMPT(refined)) },
         {
             label: 'worker:context',
-            prompt: promptHeader + RESEARCH_CONTEXT_PROMPT(refined),
+            prompt: appendNoThink(promptHeader + RESEARCH_CONTEXT_PROMPT(refined)),
             // Context owns architectural understanding, not path discovery —
             // FILES handles that. Dropping `find`/`ls` keeps the worker from
             // spawning long enumeration loops whose output then inflates
@@ -202,7 +204,7 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
         },
         {
             label: 'worker:tooling',
-            prompt: promptHeader + RESEARCH_TOOLING_PROMPT(refined)
+            prompt: appendNoThink(promptHeader + RESEARCH_TOOLING_PROMPT(refined))
         }
     ];
     const workerResults = [];
@@ -229,7 +231,7 @@ export async function phaseResearch(deps, refined, researchDeps = {}) {
             throw new Error(`Research ${name} worker failed (exit ${result.exitCode}): ${result.stderr.slice(-500)}`);
         }
         if (result.text.trim().length === 0) {
-            throw new Error(`Research ${name} worker produced no output (exit ${result.exitCode}, ${result.waitMs}ms wait + ${result.workMs}ms work${result.stderr ? ': ' + result.stderr.slice(-300) : ''})`);
+            throw new Error(`Research ${name} worker produced no output`);
         }
     }
     return `FILES\n${files.text}\n\nAPIS\n${apis.text}\n\nCONTEXT\n${context.text}\n\nTOOLING\n${tooling.text}`;

package/dist/task/widget.js

@@ -106,7 +106,16 @@ export function startWidget(ctx, getState) {
     render();
     const timer = setInterval(render, WIDGET_REFRESH_MS);
     timer.unref?.();
-    return () => clearInterval(timer);
+    return () => {
+        clearInterval(timer);
+        try {
+            ctx.ui.setWidget(WIDGET_KEY, undefined);
+        }
+        catch {
+            /* stale ctx */
+        }
+        publishWidget(WIDGET_KEY, undefined);
+    };
 }
 export function buildAutoLoaderLines(s, theme) {
     const elapsed = formatDuration(Date.now() - s.startedAt);

package/dist/workers/pi-worker-core.js

@@ -1,5 +1,6 @@
 import { getPiInvocation } from '../shared/pi-invocation.js';
 import { CHILD_BASE_ARGS, runChildDefault } from '../shared/child-process.js';
+import { LoopDetector } from '../task/loop-detector.js';
 // `--mode json` makes pi emit structured events as they happen instead of
 // buffering the assistant text and flushing on exit. That matters for the
 // wait/work timing split: in text mode the first stdout chunk only arrives at
@@ -14,12 +15,17 @@ export async function runWorker(input) {
     const invocation = getPiInvocation([...childArgs, input.prompt]);
     const tStart = Date.now();
     let tFirstByte = null;
-    const result = await runChildDefault(invocation, input.cwd, input.signal, { mode: 'json-events', onFirstByte: () => (tFirstByte = Date.now()) }, input.spawn);
+    const loopDetector = new LoopDetector(20, 5);
+    const result = await runChildDefault(invocation, input.cwd, input.signal, {
+        mode: 'json-events',
+        onFirstByte: () => (tFirstByte = Date.now()),
+        onToolCall: call => loopDetector.record(call)
+    }, input.spawn);
     const tEnd = Date.now();
     const waitMs = tFirstByte === null ? tEnd - tStart : tFirstByte - tStart;
     const workMs = tFirstByte === null ? 0 : tEnd - tFirstByte;
     return {
-        text: result.text || '',
+        text: result.text ?? '',
         exitCode: result.exitCode,
         stderr: result.stderr.trim(),
         aborted: result.aborted,

package/package.json

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