@mjasnikovs/pi-task 0.17.22 → 0.17.23

package/dist/remote/bridge.d.ts

@@ -65,6 +65,14 @@ export declare class SessionUI {
     private askLocal;
 }
 export declare function publishNotify(message: string, level: 'info' | 'warning' | 'error'): void;
+/**
+ * Abort the running agent turn — the browser Stop button. `abort()` lives on the
+ * base ExtensionContext ("Abort the current agent operation") so it works for a
+ * host chat turn, a /task phase turn, or a /task-auto run alike. The shimmed ctx
+ * inherits it from the real event ctx via its prototype, so this is safe even
+ * before the user has run a command in the terminal. No-op when nothing is running.
+ */
+export declare function interruptAgent(): void;
 /**
  * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
  * ctx.ui.notify) to connected remote viewers. Task failures and other

package/dist/remote/bridge.js

@@ -108,6 +108,16 @@ export class SessionUI {
 export function publishNotify(message, level) {
     getBridge().broadcast({ type: 'notify', message, level });
 }
+/**
+ * Abort the running agent turn — the browser Stop button. `abort()` lives on the
+ * base ExtensionContext ("Abort the current agent operation") so it works for a
+ * host chat turn, a /task phase turn, or a /task-auto run alike. The shimmed ctx
+ * inherits it from the real event ctx via its prototype, so this is safe even
+ * before the user has run a command in the terminal. No-op when nothing is running.
+ */
+export function interruptAgent() {
+    getBridge().currentCtx?.abort();
+}
 /**
  * Mirror a task lifecycle notice (the kind pi-task shows on the terminal via
  * ctx.ui.notify) to connected remote viewers. Task failures and other

package/dist/remote/events.js

@@ -1,18 +1,24 @@
 import { setAgentIdle } from './state.js';
 import { publishNotify } from './bridge.js';
-import { agentStart, appendText, textEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
+import { agentStart, appendText, textEnd, appendThinking, thinkingEnd, startTool, updateTool, endTool, agentEnd, addUserTurn, addError, addSystemNote } from './session-state.js';
 /** Mirror pi agent events into the authoritative SessionState. Each handler
  *  drives a mutator, which updates the snapshot AND broadcasts the live delta. */
 export function setupEvents(pi) {
-    pi.on('agent_start', (_event, _ctx) => {
+    pi.on('agent_start', (_event, ctx) => {
         setAgentIdle(false);
-        agentStart();
+        agentStart(ctx.model?.name);
     });
     pi.on('message_update', (event, _ctx) => {
         const ae = event.assistantMessageEvent;
         if (ae.type === 'text_delta' && 'delta' in ae && typeof ae.delta === 'string') {
             appendText(ae.delta);
         }
+        else if (ae.type === 'thinking_delta' && 'delta' in ae && typeof ae.delta === 'string') {
+            appendThinking(ae.delta);
+        }
+        else if (ae.type === 'thinking_end') {
+            thinkingEnd();
+        }
         else if (ae.type === 'error') {
             const errorMessage = 'error' in ae && ae.error && typeof ae.error.errorMessage === 'string' ?
                 ae.error.errorMessage
@@ -43,7 +49,7 @@ export function setupEvents(pi) {
     });
     pi.on('agent_end', (_event, ctx) => {
         setAgentIdle(true);
-        agentEnd(ctx.getContextUsage());
+        agentEnd(ctx.getContextUsage(), ctx.model?.name);
         // Deliberately no push: agent_end fires on EVERY host turn — every chat
         // reply, every internal phase turn inside /task, and every internal /task
         // run inside /task-auto — so a "Task finished" push here floods the device.

package/dist/remote/history.d.ts

@@ -2,6 +2,12 @@ export interface TextPart {
     kind: 'text';
     text: string;
 }
+export interface ThinkingPart {
+    kind: 'thinking';
+    text: string;
+    /** false while thinking deltas are still streaming; true once thinking_end fires. */
+    done?: boolean;
+}
 export interface ToolPart {
     kind: 'tool';
     toolCallId: string;
@@ -14,7 +20,7 @@ export interface ToolPart {
     /** Wall-clock duration once finished, shown dimly in the tool summary. */
     elapsedMs?: number;
 }
-export type Part = TextPart | ToolPart;
+export type Part = TextPart | ThinkingPart | ToolPart;
 export interface Turn {
     role: 'user' | 'assistant' | 'system';
     /** User text, error text, or a system note. Assistant content lives in `parts`. */
@@ -22,6 +28,8 @@ export interface Turn {
     /** Ordered assistant content (text + tools). */
     parts?: Part[];
     error?: boolean;
+    /** Epoch ms when the turn was committed — the client renders a dim HH:MM. */
+    ts?: number;
 }
 export declare class HistoryBuffer {
     private entries;

package/dist/remote/history.js

@@ -24,7 +24,7 @@ export class HistoryBuffer {
         return [...this.entries];
     }
     _push(entry) {
-        this.entries.push(entry);
+        this.entries.push({ ts: Date.now(), ...entry });
         if (this.entries.length > this.limit) {
             this.entries.shift();
         }

package/dist/remote/protocol.d.ts

@@ -10,10 +10,27 @@ export interface PromptResolvedMessage {
     type: 'prompt_resolved';
     id: string;
 }
-/** The single task-widget slot. `lines: null` clears it. */
+/** Structured task-widget payload — lets the browser render a real progress bar,
+ *  phase badge and elapsed clock instead of reflowing the terminal's text lines.
+ *  Always sent ALONGSIDE `lines`, which stays the authoritative fallback. */
+export interface WidgetData {
+    /** Head line, e.g. "TASK_0003 · auth routes" or "/task-auto · building". */
+    title: string;
+    /** Current phase/stage label, e.g. "refine", "implementing", "enforcing guidelines". */
+    phase: string;
+    /** Progress numerator (current step) — omitted for stages without numbering. */
+    done?: number;
+    /** Progress denominator (total steps) — omitted for stages without numbering. */
+    total?: number;
+    /** Pre-formatted elapsed clock, e.g. "2:14". */
+    elapsed?: string;
+}
+/** The single task-widget slot. `lines: null` clears it. `data` carries the
+ *  structured view (null when clearing or when a producer only has text). */
 export interface WidgetMessage {
     type: 'widget';
     lines: string[] | null;
+    data?: WidgetData | null;
 }
 export interface NotifyMessage {
     type: 'notify';
@@ -58,5 +75,9 @@ export interface ClientPromptAnswer {
     id: string;
     value: string | undefined;
 }
-export type ClientMessage = ClientChatMessage | ClientPromptAnswer;
+/** Stop the running agent turn (the browser Stop button). */
+export interface ClientInterrupt {
+    type: 'interrupt';
+}
+export type ClientMessage = ClientChatMessage | ClientPromptAnswer | ClientInterrupt;
 export declare function isClientMessage(x: unknown): x is ClientMessage;

package/dist/remote/protocol.js

@@ -6,6 +6,8 @@ export function isClientMessage(x) {
     const m = x;
     if (m.type === 'message')
         return typeof m.text === 'string';
+    if (m.type === 'interrupt')
+        return true;
     if (m.type === 'prompt_answer') {
         return typeof m.id === 'string' && (m.value === undefined || typeof m.value === 'string');
     }

package/dist/remote/register.js

@@ -1,5 +1,5 @@
 import { getConfig } from '../config/config.js';
-import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx } from './bridge.js';
+import { getBridge, dispatchRemoteLine, dispatchRemoteNewSession, makeShimmedCtx, interruptAgent } from './bridge.js';
 import { setupEvents } from './events.js';
 import { reset, addUserTurn } from './session-state.js';
 import { html } from './ui.js';
@@ -33,11 +33,15 @@ export function registerRemote(pi) {
                         S.send?.(plain);
                     }
                     else {
-                        S.send?.(plain, { deliverAs: 'followUp' });
+                        // Mid-run: steer the live turn (inject the message into the
+                        // current generation) rather than queueing it for after, so a
+                        // remote nudge lands immediately — matching the composer's
+                        // "delivered mid-run" affordance.
+                        S.send?.(plain, { deliverAs: 'steer' });
                     }
                 }
             });
-        }, wsUrl => html(wsUrl));
+        }, wsUrl => html(wsUrl), interruptAgent);
         // 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' }));

package/dist/remote/server.d.ts

@@ -28,5 +28,5 @@ export declare function getLocalIPs(nets?: NodeJS.Dict<import("node:os").Network
  *  Tailscale line uses the MagicDNS host when known (resolves to the same node,
  *  but is what SSH and webpush certs need), falling back to the raw IP. */
 export declare function formatAddresses(ips: LocalIPs, port: number, tsHost?: string): AddressLine[];
-export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string): Promise<ServerHandle>;
+export declare function startServer(onMessage: MessageCallback, getHtml: (wsUrl: string) => string, onInterrupt?: () => void): Promise<ServerHandle>;
 export {};

package/dist/remote/server.js

@@ -64,7 +64,7 @@ async function findPort(start, max) {
     }
     throw new Error(`No free port found in range ${start}–${start + max - 1}`);
 }
-export async function startServer(onMessage, getHtml) {
+export async function startServer(onMessage, getHtml, onInterrupt) {
     const port = await findPort(8800, 100);
     const ips = getLocalIPs();
     const ip = ips.primary;
@@ -159,6 +159,10 @@ export async function startServer(onMessage, getHtml) {
             }
             if (!isClientMessage(msg))
                 return;
+            if (msg.type === 'interrupt') {
+                onInterrupt?.();
+                return;
+            }
             if (msg.type === 'prompt_answer') {
                 answerPrompt(msg.id, msg.value);
                 return;

package/dist/remote/session-state.d.ts

@@ -1,6 +1,6 @@
 import { HistoryBuffer } from './history.js';
 import type { Turn, Part } from './history.js';
-import type { ContextUsage, PromptMessage } from './protocol.js';
+import type { ContextUsage, PromptMessage, WidgetData } from './protocol.js';
 export interface LiveTurn {
     /** Ordered assistant content (text segments + tool calls) for this run. */
     parts: Part[];
@@ -14,16 +14,21 @@ export interface SnapshotMessage {
     live: LiveTurn | null;
     agentRunning: boolean;
     taskWidget: string[] | null;
+    taskWidgetData: WidgetData | null;
     prompt: PromptMessage | null;
     context: ContextUsage | null;
+    model: string | null;
 }
 interface SessionState {
     history: HistoryBuffer;
     live: LiveTurn | null;
     agentRunning: boolean;
     taskWidget: string[] | null;
+    taskWidgetData: WidgetData | null;
     prompt: PromptMessage | null;
     context: ContextUsage | null;
+    /** Human-readable active model name (e.g. "Qwen3.6 27B"), for the header chip. */
+    model: string | null;
     /** tool start timestamps (ms), keyed by toolCallId — kept off the serialized
      *  parts so it never reaches the client; used only to compute elapsedMs. */
     toolStarts: Record<string, number>;
@@ -33,20 +38,26 @@ interface SessionState {
 export declare function getState(): SessionState;
 /** @internal Test-only: swap the broadcast sink to capture emitted deltas. */
 export declare function _setSink(fn: (msg: unknown) => void): void;
-export declare function agentStart(): void;
+export declare function agentStart(model?: string): void;
 export declare function appendText(delta: string): void;
 export declare function textEnd(): void;
+/** Accumulate a reasoning/thinking delta into the current thinking part (a new
+ *  part opens when the previous one is closed or the last part isn't thinking).
+ *  Stored as a part kind so a reconnect snapshot replays the collapsed block. */
+export declare function appendThinking(delta: string): void;
+export declare function thinkingEnd(): void;
 export declare function startTool(toolCallId: string, toolName: string, args: unknown): void;
 export declare function updateTool(toolCallId: string, partialResult: unknown): void;
 export declare function endTool(toolCallId: string, toolName: string, result: unknown, isError: boolean): void;
-export declare function agentEnd(context: ContextUsage): void;
+export declare function agentEnd(context: ContextUsage, model?: string): void;
 export declare function addUserTurn(text: string): void;
 export declare function addError(message: string): void;
 /** A persistent inline note (committed to the transcript so it survives reconnect)
  *  plus a live delta so connected clients render it immediately. */
 export declare function addSystemNote(text: string): void;
-/** The single task-widget slot. Empty/undefined lines clear it. */
-export declare function setTaskWidget(lines: string[] | null | undefined): void;
+/** The single task-widget slot. Empty/undefined lines clear it. `data` is the
+ *  structured view rendered by the browser; the lines remain the fallback. */
+export declare function setTaskWidget(lines: string[] | null | undefined, data?: WidgetData | null): void;
 export declare function setPrompt(prompt: PromptMessage): void;
 export declare function clearPrompt(id: string): void;
 export declare function setContext(context: ContextUsage): void;

package/dist/remote/session-state.js

@@ -18,8 +18,10 @@ function fresh() {
         live: null,
         agentRunning: false,
         taskWidget: null,
+        taskWidgetData: null,
         prompt: null,
         context: null,
+        model: null,
         toolStarts: {},
         sink: wsBroadcast
     };
@@ -39,11 +41,13 @@ function ensureLive(s) {
     return s.live;
 }
 // ─── Mutators ────────────────────────────────────────────────────────────────
-export function agentStart() {
+export function agentStart(model) {
     const s = getState();
     s.live = { parts: [], textOpen: false };
     s.agentRunning = true;
-    s.sink({ type: 'agent_start' });
+    if (model)
+        s.model = model;
+    s.sink({ type: 'agent_start', model: s.model });
 }
 export function appendText(delta) {
     const s = getState();
@@ -64,6 +68,29 @@ export function textEnd() {
         s.live.textOpen = false; // next text starts a new segment
     s.sink({ type: 'text_end' });
 }
+/** Accumulate a reasoning/thinking delta into the current thinking part (a new
+ *  part opens when the previous one is closed or the last part isn't thinking).
+ *  Stored as a part kind so a reconnect snapshot replays the collapsed block. */
+export function appendThinking(delta) {
+    const s = getState();
+    const live = ensureLive(s);
+    const last = live.parts[live.parts.length - 1];
+    if (last && last.kind === 'thinking' && !last.done) {
+        last.text += delta;
+    }
+    else {
+        live.parts.push({ kind: 'thinking', text: delta, done: false });
+    }
+    live.textOpen = false; // a following text delta begins a fresh bubble
+    s.sink({ type: 'thinking_delta', delta });
+}
+export function thinkingEnd() {
+    const s = getState();
+    const last = s.live?.parts[s.live.parts.length - 1];
+    if (last && last.kind === 'thinking')
+        last.done = true;
+    s.sink({ type: 'thinking_end' });
+}
 export function startTool(toolCallId, toolName, args) {
     const s = getState();
     const live = ensureLive(s);
@@ -114,14 +141,16 @@ export function endTool(toolCallId, toolName, result, isError) {
     }
     s.sink({ type: 'tool_end', toolCallId, toolName, result, isError, elapsedMs });
 }
-export function agentEnd(context) {
+export function agentEnd(context, model) {
     const s = getState();
     if (s.live)
         s.history.addAssistantTurn(s.live.parts);
     s.live = null;
     s.agentRunning = false;
     s.context = context;
-    s.sink({ type: 'agent_end', contextUsage: context });
+    if (model)
+        s.model = model;
+    s.sink({ type: 'agent_end', contextUsage: context, model: s.model });
 }
 export function addUserTurn(text) {
     const s = getState();
@@ -142,11 +171,13 @@ export function addSystemNote(text) {
     s.history.addSystemNote(text);
     s.sink({ type: 'system_note', text });
 }
-/** The single task-widget slot. Empty/undefined lines clear it. */
-export function setTaskWidget(lines) {
+/** The single task-widget slot. Empty/undefined lines clear it. `data` is the
+ *  structured view rendered by the browser; the lines remain the fallback. */
+export function setTaskWidget(lines, data) {
     const s = getState();
     s.taskWidget = lines && lines.length ? lines : null;
-    s.sink({ type: 'widget', lines: s.taskWidget });
+    s.taskWidgetData = s.taskWidget ? (data ?? null) : null;
+    s.sink({ type: 'widget', lines: s.taskWidget, data: s.taskWidgetData });
 }
 export function setPrompt(prompt) {
     const s = getState();
@@ -170,8 +201,11 @@ export function reset() {
     s.live = null;
     s.agentRunning = false;
     s.taskWidget = null;
+    s.taskWidgetData = null;
     s.prompt = null;
     s.context = null;
+    // Deliberately keep s.model: the active model doesn't change across a /new,
+    // so the header chip needn't blank and re-fill on every session switch.
     s.sink({ type: 'reset' });
 }
 /** Serialize the whole state for a (re)connecting client. */
@@ -183,7 +217,9 @@ export function snapshot() {
         live: s.live ? { parts: [...s.live.parts], textOpen: s.live.textOpen } : null,
         agentRunning: s.agentRunning,
         taskWidget: s.taskWidget,
+        taskWidgetData: s.taskWidgetData,
         prompt: s.prompt,
-        context: s.context
+        context: s.context,
+        model: s.model
     };
 }

package/dist/remote/ui-render.js

@@ -156,8 +156,12 @@ export function renderModule() {
       for (var k = 0; k < blocks.length; k++) {
         var b = blocks[k];
         if (b.type === 'code') {
-          out += '<div class="code-block">'
-            + (b.lang ? '<div class="code-lang">' + escHtml(b.lang) + '</div>' : '')
+          // Header row carries the language label and a copy button (wired by
+          // event delegation in clientScript — it reads the <code> textContent).
+          out += '<div class="code-block"><div class="code-head">'
+            + '<div class="code-lang">' + (b.lang ? escHtml(b.lang) : '') + '</div>'
+            + '<button class="copy-btn" type="button" aria-label="Copy code">Copy</button>'
+            + '</div>'
             + '<pre><code>' + syntaxHighlight(b.content, b.lang) + '</code></pre></div>';
         } else {
           out += renderProse(b.content);