@mjasnikovs/pi-task 0.4.4 → 0.5.0

package/dist/remote/bridge.d.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import type { ExtensionAPI, ExtensionCommandContext, ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { PromptMessage, ServerMessage } from './protocol.js';
 export interface BridgeState {
     /** promptId → resolver that settles the remote side of an ask() race. */
@@ -46,6 +46,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 +68,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

@@ -97,6 +97,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 +142,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 +179,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/register.js

@@ -1,5 +1,5 @@
 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';
@@ -12,20 +12,12 @@ if (!_g.__piRemote)
 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 +26,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);
@@ -55,18 +41,18 @@ export function registerRemote(pi) {
         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) => {
@@ -92,15 +78,12 @@ 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 qr = await qrLines(primaryUrl);
-                // Labeled, block-aligned address lines: Tailscale + LAN when present.
                 const addrs = 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);
@@ -110,8 +93,6 @@ export function registerRemote(pi) {
                     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/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;
@@ -50,7 +50,7 @@ export function html(wsUrl) {
     #header .title { font-weight: bold; color: var(--mauve); letter-spacing: 0.05em; }
     #header .status { color: var(--subtext0); font-size: 11px; }
     #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; }
@@ -92,9 +92,10 @@ export function html(wsUrl) {
     .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);
@@ -165,25 +166,48 @@ 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; }
+      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; padding: 8px 12px; border-radius: 6px;
       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="title">pi-task remote</span>
     <span class="status" id="client-status">connecting…</span>
   </div>
   <div id="chat-log"></div>
@@ -195,8 +219,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>
@@ -220,12 +249,16 @@ export function html(wsUrl) {
     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 = '';
@@ -460,33 +493,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) {

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.5.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",