@mjasnikovs/pi-task 0.15.2 → 0.16.1

package/dist/remote/server.js

@@ -109,14 +109,38 @@ export async function startServer(onMessage, getHtml) {
         }
     });
     const wss = new WebSocketServer({ server: httpServer, path: '/ws' });
+    // Track every accepted TCP socket so stop() can forcibly destroy lingering
+    // keep-alive / WebSocket connections. Without this, httpServer.close() only
+    // stops accepting new connections and waits for existing ones to drain — an
+    // open browser tab never drains, so the listening server and its sockets
+    // stay as active event-loop handles forever. In headless print mode the host
+    // exits by natural event-loop drain (it sets process.exitCode and returns,
+    // with no process.exit()), so these lingering handles keep the pi process
+    // alive indefinitely — which blocks `docker stop` / OS shutdown until the
+    // SIGKILL grace timeout fires. A/B-proven: terminating clients + destroying
+    // sockets here makes the loop drain in ~2ms instead of never.
+    const sockets = new Set();
+    httpServer.on('connection', s => {
+        sockets.add(s);
+        s.on('close', () => sockets.delete(s));
+    });
     const handle = {
         port,
         ip,
         ips,
         onFirstConnect: null,
         stop() {
+            // Terminate WebSocket clients (immediate close, no drain), then
+            // destroy any remaining raw sockets, then close the servers so the
+            // event loop has no lingering handles holding the process open.
+            for (const ws of wss.clients)
+                ws.terminate();
             wss.close();
+            for (const s of sockets)
+                s.destroy();
+            sockets.clear();
             httpServer.close();
+            httpServer.closeAllConnections?.();
         }
     };
     wss.on('connection', ws => {

package/dist/task/impl-widget.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Implementation-turn status widget.
+ *
+ * The phase widget (widget.ts) is disposed at spec-handoff, so the host agent's
+ * implementation turn — the longest, most visible part of a run — otherwise shows
+ * only pi's bare "⠸ Working…" indicator. This module keeps the SAME rich status
+ * block alive across that turn (task id · implementing/elapsed/context bar · ↳ last
+ * tool), driven by the host's own live `ctx.getContextUsage()`.
+ *
+ * It is event-driven rather than poll-wrapped because the two delivery paths differ:
+ *
+ *   • /task (fire-and-forget): the command returns right after `sendUserMessage`,
+ *     so the host runs the impl turn AFTER our code is gone — only an `agent_start`
+ *     handler can pick it up. Armed one-shot: `agent_end` disarms it.
+ *   • /task-auto (awaited): the caller blocks across `waitForIdle` plus any
+ *     compaction-resume / steer turns. Armed sticky: each `agent_start` re-shows the
+ *     widget, `agent_end` only hides it between turns, and the caller disarms once
+ *     the whole implementation phase has settled.
+ *
+ * Only one task runs at a time (single active task), so a single module-level slot
+ * is sufficient.
+ */
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+export interface ImplWidgetMeta {
+    taskId: string;
+    title: string;
+    label?: string;
+}
+/**
+ * Arm the implementation widget just before the spec is handed off. `oneShot`
+ * true (fire-and-forget /task) lets `agent_end` disarm it after the single turn;
+ * false (awaited /task-auto) keeps it armed until `disarmImplWidget` is called.
+ */
+export declare function armImplWidget(meta: ImplWidgetMeta, opts: {
+    oneShot: boolean;
+}): void;
+/** Tear down the widget and clear the armed slot (sticky/awaited path). */
+export declare function disarmImplWidget(): void;
+/** Wire the agent-lifecycle handlers that drive the widget. Call once at setup. */
+export declare function setupImplWidget(pi: ExtensionAPI): void;

package/dist/task/impl-widget.js

@@ -0,0 +1,131 @@
+/**
+ * Implementation-turn status widget.
+ *
+ * The phase widget (widget.ts) is disposed at spec-handoff, so the host agent's
+ * implementation turn — the longest, most visible part of a run — otherwise shows
+ * only pi's bare "⠸ Working…" indicator. This module keeps the SAME rich status
+ * block alive across that turn (task id · implementing/elapsed/context bar · ↳ last
+ * tool), driven by the host's own live `ctx.getContextUsage()`.
+ *
+ * It is event-driven rather than poll-wrapped because the two delivery paths differ:
+ *
+ *   • /task (fire-and-forget): the command returns right after `sendUserMessage`,
+ *     so the host runs the impl turn AFTER our code is gone — only an `agent_start`
+ *     handler can pick it up. Armed one-shot: `agent_end` disarms it.
+ *   • /task-auto (awaited): the caller blocks across `waitForIdle` plus any
+ *     compaction-resume / steer turns. Armed sticky: each `agent_start` re-shows the
+ *     widget, `agent_end` only hides it between turns, and the caller disarms once
+ *     the whole implementation phase has settled.
+ *
+ * Only one task runs at a time (single active task), so a single module-level slot
+ * is sufficient.
+ */
+import { WIDGET_KEY, WIDGET_REFRESH_MS, buildImplLines } from './widget.js';
+import { setTaskWidget } from '../remote/session-state.js';
+let armed = null;
+let lastLine;
+let timer = null;
+let activeCtx = null;
+/** Map the host's live context usage to the widget snapshot, or undefined when the
+ *  token count is unknown (e.g. right after compaction, before the next response). */
+function snapshot(ctx) {
+    const u = ctx.getContextUsage?.();
+    if (!u || u.tokens == null)
+        return undefined;
+    return { tokens: u.tokens, contextWindow: u.contextWindow, percent: u.percent ?? 0 };
+}
+function render() {
+    if (!armed || !activeCtx)
+        return;
+    const ctx = activeCtx;
+    const state = {
+        taskId: armed.meta.taskId,
+        title: armed.meta.title,
+        label: armed.meta.label,
+        startedAt: armed.startedAt,
+        lastLine,
+        contextUsage: snapshot(ctx)
+    };
+    try {
+        ctx.ui.setWidget(WIDGET_KEY, buildImplLines(state, ctx.ui.theme));
+    }
+    catch {
+        /* stale ctx */
+    }
+    setTaskWidget(buildImplLines(state, undefined)); // un-themed for the wire
+}
+function startTimer() {
+    if (timer)
+        return;
+    render();
+    timer = setInterval(render, WIDGET_REFRESH_MS);
+    timer.unref?.();
+}
+function stopTimer() {
+    if (timer) {
+        clearInterval(timer);
+        timer = null;
+    }
+}
+function clearWidget() {
+    try {
+        activeCtx?.ui.setWidget(WIDGET_KEY, undefined);
+    }
+    catch {
+        /* stale ctx */
+    }
+    setTaskWidget(undefined);
+}
+/** One-line summary of a host tool call for the `↳` trailer (best-effort). */
+function formatToolLine(toolName, args) {
+    const a = (args ?? {});
+    const field = a.path ?? a.file_path ?? a.command ?? a.pattern ?? a.prompt ?? a.query ?? a.url;
+    const detail = typeof field === 'string' ? ' ' + field.replace(/\s+/g, ' ').trim() : '';
+    return `${toolName}${detail}`;
+}
+/**
+ * Arm the implementation widget just before the spec is handed off. `oneShot`
+ * true (fire-and-forget /task) lets `agent_end` disarm it after the single turn;
+ * false (awaited /task-auto) keeps it armed until `disarmImplWidget` is called.
+ */
+export function armImplWidget(meta, opts) {
+    armed = { meta, oneShot: opts.oneShot, startedAt: Date.now() };
+    lastLine = undefined;
+}
+/** Tear down the widget and clear the armed slot (sticky/awaited path). */
+export function disarmImplWidget() {
+    stopTimer();
+    clearWidget();
+    armed = null;
+    activeCtx = null;
+    lastLine = undefined;
+}
+/** Wire the agent-lifecycle handlers that drive the widget. Call once at setup. */
+export function setupImplWidget(pi) {
+    pi.on('agent_start', (_event, ctx) => {
+        if (!armed)
+            return;
+        activeCtx = ctx;
+        lastLine = undefined;
+        startTimer();
+    });
+    pi.on('tool_execution_start', (event, _ctx) => {
+        if (!armed)
+            return;
+        lastLine = formatToolLine(event.toolName, event.args);
+    });
+    pi.on('agent_end', (_event, _ctx) => {
+        if (!armed)
+            return;
+        stopTimer();
+        clearWidget();
+        // Fire-and-forget /task: the single impl turn is over, so disarm. Awaited
+        // /task-auto leaves the slot armed so the next compaction-resume / steer
+        // turn re-shows it; the caller disarms when the phase truly settles.
+        if (armed.oneShot) {
+            armed = null;
+            activeCtx = null;
+            lastLine = undefined;
+        }
+    });
+}

package/dist/task/orchestrator.d.ts

@@ -28,6 +28,11 @@ export declare class TaskRunner {
     private readonly _onStart;
     private readonly _planContext;
     private readonly _fixInstruction;
+    /** True when the caller awaits the implementation turn (waitForImplementation):
+     *  the impl widget stays armed across the whole impl phase (incl. compaction /
+     *  steer turns) and is disarmed here. False for fire-and-forget /task, where the
+     *  widget is armed one-shot and its own agent_end disarms it. */
+    private readonly _implAwaited;
     private readonly _abort;
     private readonly _startedAt;
     private readonly _widgetState;
@@ -43,7 +48,7 @@ export declare class TaskRunner {
      */
     private readonly _timings;
     private _currentPhaseChildren;
-    constructor(ctx: ExtensionCommandContext, cwd: string, rawPrompt: string, resumeId?: string, sendSpec?: (spec: string) => Promise<void>, spawnFn?: SpawnFn, onStart?: (taskId: string) => void | Promise<void>, planContext?: string, fixInstruction?: string);
+    constructor(ctx: ExtensionCommandContext, cwd: string, rawPrompt: string, resumeId?: string, sendSpec?: (spec: string) => Promise<void>, spawnFn?: SpawnFn, onStart?: (taskId: string) => void | Promise<void>, planContext?: string, fixInstruction?: string, implAwaited?: boolean);
     get taskId(): string;
     get signal(): AbortSignal;
     /** Return the current widget state, or null if not started. */

package/dist/task/orchestrator.js

@@ -23,6 +23,7 @@ import { PHASE_INDEX, PHASE_ORDER, RESUMABLE_STATES } from './task-types.js';
 import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parsers.js';
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
+import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.js';
 import { publishViewer, publishNotify, registerBridgeCommand, getBridge } from '../remote/bridge.js';
 import { pushNotify } from '../remote/push.js';
 import { parseVerifyBlock } from './spec-validation.js';
@@ -54,6 +55,11 @@ export class TaskRunner {
     _onStart;
     _planContext;
     _fixInstruction;
+    /** True when the caller awaits the implementation turn (waitForImplementation):
+     *  the impl widget stays armed across the whole impl phase (incl. compaction /
+     *  steer turns) and is disarmed here. False for fire-and-forget /task, where the
+     *  widget is armed one-shot and its own agent_end disarms it. */
+    _implAwaited;
     _abort = new AbortController();
     _startedAt;
     _widgetState;
@@ -69,7 +75,7 @@ export class TaskRunner {
      */
     _timings = [];
     _currentPhaseChildren = null;
-    constructor(ctx, cwd, rawPrompt, resumeId, sendSpec, spawnFn, onStart, planContext, fixInstruction) {
+    constructor(ctx, cwd, rawPrompt, resumeId, sendSpec, spawnFn, onStart, planContext, fixInstruction, implAwaited) {
         this._ctx = ctx;
         this._cwd = cwd;
         this._rawPrompt = rawPrompt;
@@ -78,6 +84,7 @@ export class TaskRunner {
         this._onStart = onStart;
         this._planContext = planContext;
         this._fixInstruction = fixInstruction;
+        this._implAwaited = implAwaited ?? false;
         this._startedAt = Date.now();
         // We'll populate id/title/phase lazily in run().
         // Placeholder — real values set in run().
@@ -265,13 +272,30 @@ export class TaskRunner {
     }
     async _deliverSpec(ctx) {
         const spec = this._specForDelivery();
+        // Keep the rich status block alive across the implementation turn (the phase
+        // widget was disposed at handoff). Awaited (/task-auto) stays armed across all
+        // sub-turns and is disarmed here; fire-and-forget (/task) arms one-shot and its
+        // own agent_end disarms it after the single turn.
+        const meta = {
+            taskId: this._widgetState.taskId,
+            title: this._widgetState.title,
+            label: this._widgetState.label
+        };
         if (this._sendSpec) {
-            await this._sendSpec(spec);
+            armImplWidget(meta, { oneShot: !this._implAwaited });
+            try {
+                await this._sendSpec(spec);
+            }
+            finally {
+                if (this._implAwaited)
+                    disarmImplWidget();
+            }
             return;
         }
         if (!piApi) {
             throw new Error('extension not initialised (no ExtensionAPI captured)');
         }
+        armImplWidget(meta, { oneShot: true });
         if (ctx.isIdle()) {
             piApi.sendUserMessage(spec);
         }
@@ -494,7 +518,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                     if (!interrupted)
                         implError = implementationError(newCtx);
                 }
-            }, opts.spawnFn, opts.onStart, opts.planContext, opts.fixInstruction);
+            }, opts.spawnFn, opts.onStart, opts.planContext, opts.fixInstruction, opts.waitForImplementation);
             await runner.run();
             taskId = runner.taskId;
         }
@@ -643,6 +667,7 @@ async function handleTaskCancel(_args, ctx) {
 // ─── Entry point ─────────────────────────────────────────────────────────────
 export function registerTask(pi) {
     piApi = pi;
+    setupImplWidget(pi);
     registerBridgeCommand(pi, 'task', {
         description: 'Start a new task. Usage: /task <prompt>',
         handler: handleTask

package/dist/task/widget.d.ts

@@ -63,4 +63,14 @@ export declare function buildAutoLoaderLines(s: AutoLoaderState, theme?: WidgetT
  * (returns a no-op disposer) when there's no UI.
  */
 export declare function startAutoLoader(ctx: ExtensionCommandContext, getState: () => AutoLoaderState | null): () => void;
+export interface ImplState {
+    taskId: string;
+    title: string;
+    /** Short display label compressed from `title`; falls back to a truncation when absent. */
+    label?: string;
+    startedAt: number;
+    lastLine?: string;
+    contextUsage?: ContextSnapshot;
+}
+export declare function buildImplLines(s: ImplState, theme?: WidgetTheme): string[];
 export declare function flashTerminalWidget(ctx: ExtensionCommandContext, state: Exclude<TaskState, 'pending' | 'in_progress' | 'completed'>, taskId: string, reason: string | undefined): void;

package/dist/task/widget.js

@@ -170,6 +170,21 @@ export function startAutoLoader(ctx, getState) {
         setTaskWidget(undefined);
     };
 }
+export function buildImplLines(s, theme) {
+    const elapsed = formatDuration(Date.now() - s.startedAt);
+    const head = `${s.taskId} · ${titleForDisplay(s)}`;
+    let detail = `implementing · ${elapsed}`;
+    if (s.contextUsage) {
+        const ctxDetail = formatContextDetail(s.contextUsage, theme);
+        if (ctxDetail)
+            detail += ` · ${ctxDetail}`;
+    }
+    const lines = [head, detail];
+    const trailer = lastLineTrailer(s.lastLine, theme);
+    if (trailer)
+        lines.push(trailer);
+    return lines;
+}
 export function flashTerminalWidget(ctx, state, taskId, reason) {
     if (!ctx.hasUI)
         return;

package/package.json

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