@mjasnikovs/pi-task 0.7.0 → 0.7.2

package/dist/task/auto-io.js

@@ -53,17 +53,15 @@ export function parseTaskList(body) {
             continue;
         const done = m[1].toLowerCase() === 'x';
         const rest = m[2].trim();
-        if (done) {
-            const idm = PRODUCED_ID_RE.exec(rest);
-            if (idm) {
-                entries.push({ index, title: idm[2].trim(), done: true, producedId: idm[1] });
-            }
-            else {
-                entries.push({ index, title: rest, done: true });
-            }
+        // A line carries a stamped TASK_NNNN id both when done (the completed
+        // inner task) and when merely started — an unchecked, stamped line is an
+        // in-progress entry whose inner task can be resumed.
+        const idm = PRODUCED_ID_RE.exec(rest);
+        if (idm) {
+            entries.push({ index, title: idm[2].trim(), done, producedId: idm[1] });
         }
         else {
-            entries.push({ index, title: rest, done: false });
+            entries.push({ index, title: rest, done });
         }
         index++;
     }
@@ -76,8 +74,8 @@ export function buildAutoBody(feature, clarifications, titles) {
         + `## clarifications\n\n${clarifications.trim() || '(none)'}\n\n`
         + `## tasks\n\n${tasks}\n`);
 }
-/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
-export async function checkOffTask(cwd, id, index, producedId, title) {
+/** Rewrite the Nth checkbox line of the "## tasks" section in place. */
+async function rewriteTaskLine(cwd, id, index, render, label) {
     const { body } = await readTaskFile(cwd, id);
     const section = extractSection(body, 'tasks') ?? '';
     const lines = section.split('\n');
@@ -87,15 +85,28 @@ export async function checkOffTask(cwd, id, index, producedId, title) {
             continue;
         seen++;
         if (seen === index) {
-            lines[i] = producedId ? `- [x] ${producedId}  ${title}` : `- [x] ${title}`;
+            lines[i] = render();
             break;
         }
     }
     if (seen < index) {
-        throw new Error(`checkOffTask: index ${index} out of range in ${id} (only ${seen + 1} checkboxes found)`);
+        throw new Error(`${label}: index ${index} out of range in ${id} (only ${seen + 1} checkboxes found)`);
     }
     await setTaskSection(cwd, id, 'tasks', lines.join('\n'));
 }
+/** Check off the Nth checkbox line, stamping the produced TASK_NNNN id. */
+export async function checkOffTask(cwd, id, index, producedId, title) {
+    await rewriteTaskLine(cwd, id, index, () => (producedId ? `- [x] ${producedId}  ${title}` : `- [x] ${title}`), 'checkOffTask');
+}
+/**
+ * Stamp the inner TASK_NNNN id onto the Nth (still-unchecked) entry the moment
+ * the inner task is allocated. This links the AUTO entry to its in-progress
+ * inner task so /task-auto-resume can continue it from its saved phase instead
+ * of starting a brand-new task — matching how /task-resume behaves.
+ */
+export async function stampTaskInProgress(cwd, id, index, producedId, title) {
+    await rewriteTaskLine(cwd, id, index, () => `- [ ] ${producedId}  ${title}`, 'stampTaskInProgress');
+}
 /** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
 export async function findResumableAuto(cwd) {
     await ensureTasksDir(cwd);

package/dist/task/auto-orchestrator.d.ts

@@ -7,7 +7,12 @@ import { type CommitResult } from './auto-commit.js';
  */
 export interface AutoDeps {
     runChild: (name: string, tools: string, prompt: string) => Promise<string>;
-    runTask: (ctx: ExtensionCommandContext, cwd: string, title: string) => Promise<RunSingleTaskResult>;
+    runTask: (ctx: ExtensionCommandContext, cwd: string, title: string, opts?: {
+        /** Resume this inner task id instead of allocating a fresh one. */
+        resumeId?: string;
+        /** Called with the inner task id once its file exists, before phases. */
+        onStart?: (taskId: string) => void | Promise<void>;
+    }) => Promise<RunSingleTaskResult>;
     /** Snapshot the working tree into one commit after a task passes. */
     commit: (cwd: string, message: string) => Promise<CommitResult>;
 }

package/dist/task/auto-orchestrator.js

@@ -11,7 +11,7 @@ import { runSingleTask } from './orchestrator.js';
 import { parseClarifyList, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
-import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, findResumableAuto } from './auto-io.js';
+import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter } from './task-io.js';
 import { gitCommitAll } from './auto-commit.js';
 import { runPhaseChild, USER_CANCELLED } from './child-runner.js';
@@ -176,7 +176,11 @@ function defaultDeps(ctx, cwd, signal, title) {
                 stopLoader();
             }
         },
-        runTask: (c, cwd2, t) => runSingleTask(c, cwd2, t, { waitForImplementation: true }),
+        runTask: (c, cwd2, t, opts) => runSingleTask(c, cwd2, t, {
+            waitForImplementation: true,
+            resumeId: opts?.resumeId,
+            onStart: opts?.onStart
+        }),
         commit: (cwd2, message) => gitCommitAll(cwd2, message, signal)
     };
 }
@@ -208,7 +212,15 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 return;
             }
             active.ui.notify(`${id}: task ${next.index + 1}/${entries.length} — ${next.title}`, 'info');
-            const res = await deps.runTask(active, cwd, next.title);
+            // If this entry already has a stamped inner id, it was started in a
+            // previous (interrupted) run — resume it from its saved phase rather
+            // than spawning a fresh task. Otherwise stamp the freshly-allocated id
+            // onto the entry the moment it exists, so an interruption here is
+            // resumable too. This mirrors /task-resume's continue-don't-restart.
+            const res = await deps.runTask(active, cwd, next.title, {
+                resumeId: next.producedId,
+                onStart: next.producedId ? undefined : (innerId => stampTaskInProgress(cwd, id, next.index, innerId, next.title))
+            });
             active = res.ctx ?? active;
             if (res.sessionCancelled) {
                 active.ui.notify(`${id} paused — could not start a session. Run /task-auto-resume to retry.`, 'warning');

package/dist/task/orchestrator.d.ts

@@ -25,6 +25,7 @@ export declare class TaskRunner {
     private readonly _rawPrompt;
     private readonly _resumeId;
     private readonly _sendSpec;
+    private readonly _onStart;
     private readonly _abort;
     private readonly _startedAt;
     private readonly _widgetState;
@@ -40,7 +41,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);
+    constructor(ctx: ExtensionCommandContext, cwd: string, rawPrompt: string, resumeId?: string, sendSpec?: (spec: string) => Promise<void>, spawnFn?: SpawnFn, onStart?: (taskId: string) => void | Promise<void>);
     get taskId(): string;
     get signal(): AbortSignal;
     /** Return the current widget state, or null if not started. */
@@ -64,6 +65,10 @@ export interface RunSingleTaskOptions {
     resumeId?: string;
     /** Test seam: spawn function forwarded to TaskRunner. */
     spawnFn?: SpawnFn;
+    /** Called with the resolved task id once its file exists, before any phase
+     *  work. Lets callers record the id (e.g. stamp the /task-auto entry) so an
+     *  interrupted run can be resumed instead of restarted. */
+    onStart?: (taskId: string) => void | Promise<void>;
 }
 export interface RunSingleTaskResult {
     taskId: string;

package/dist/task/orchestrator.js

@@ -45,6 +45,7 @@ export class TaskRunner {
     _rawPrompt;
     _resumeId;
     _sendSpec;
+    _onStart;
     _abort = new AbortController();
     _startedAt;
     _widgetState;
@@ -60,12 +61,13 @@ export class TaskRunner {
      */
     _timings = [];
     _currentPhaseChildren = null;
-    constructor(ctx, cwd, rawPrompt, resumeId, sendSpec, spawnFn) {
+    constructor(ctx, cwd, rawPrompt, resumeId, sendSpec, spawnFn, onStart) {
         this._ctx = ctx;
         this._cwd = cwd;
         this._rawPrompt = rawPrompt;
         this._resumeId = resumeId;
         this._sendSpec = sendSpec;
+        this._onStart = onStart;
         this._startedAt = Date.now();
         // We'll populate id/title/phase lazily in run().
         // Placeholder — real values set in run().
@@ -157,6 +159,11 @@ export class TaskRunner {
             };
             await writeTaskFile(cwd, fm, `\n## raw prompt\n\n${this._rawPrompt.trim() || '(none)'}\n`);
         }
+        // Surface the resolved id now that the task file exists, so callers (e.g.
+        // the /task-auto loop) can link this run to their own bookkeeping before
+        // any phase work — and recover it if the session dies mid-pipeline.
+        if (this._onStart)
+            await this._onStart(id);
         // Register as active.
         this._widgetState.taskId = id;
         this._widgetState.title = title;
@@ -279,7 +286,7 @@ export async function runSingleTask(ctx, cwd, rawPrompt, opts = {}) {
                 await newCtx.sendUserMessage(spec);
                 if (opts.waitForImplementation)
                     await newCtx.waitForIdle();
-            }, opts.spawnFn);
+            }, opts.spawnFn, opts.onStart);
             await runner.run();
             taskId = runner.taskId;
         }

package/dist/task/widget.js

@@ -5,7 +5,7 @@
  * context usage, and the latest child-process line.
  */
 import { PHASE_INDEX, PHASE_ORDER } from './task-file.js';
-import { publishWidget } from '../remote/bridge.js';
+import { setTaskWidget } from '../remote/session-state.js';
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const WIDGET_KEY = 'pi-tasks';
 export const AUTO_WIDGET_KEY = 'pi-task-auto';
@@ -101,7 +101,7 @@ export function startWidget(ctx, getState) {
         catch {
             /* stale ctx */
         }
-        publishWidget(WIDGET_KEY, plain);
+        setTaskWidget(plain);
     };
     render();
     const timer = setInterval(render, WIDGET_REFRESH_MS);
@@ -114,7 +114,7 @@ export function startWidget(ctx, getState) {
         catch {
             /* stale ctx */
         }
-        publishWidget(WIDGET_KEY, undefined);
+        setTaskWidget(undefined);
     };
 }
 export function buildAutoLoaderLines(s, theme) {
@@ -150,7 +150,7 @@ export function startAutoLoader(ctx, getState) {
         catch {
             /* stale ctx */
         }
-        publishWidget(AUTO_WIDGET_KEY, plain);
+        setTaskWidget(plain);
     };
     render();
     const timer = setInterval(render, WIDGET_REFRESH_MS);
@@ -163,7 +163,7 @@ export function startAutoLoader(ctx, getState) {
         catch {
             /* stale ctx */
         }
-        publishWidget(AUTO_WIDGET_KEY, undefined);
+        setTaskWidget(undefined);
     };
 }
 export function flashTerminalWidget(ctx, state, taskId, reason) {
@@ -185,7 +185,7 @@ export function flashTerminalWidget(ctx, state, taskId, reason) {
         : `✘ ${taskId} failed${reason ? ': ' + reason : ''}`;
     try {
         ctx.ui.setWidget(WIDGET_KEY, [line]);
-        publishWidget(WIDGET_KEY, [plainLine]);
+        setTaskWidget([plainLine]);
     }
     catch {
         /* stale ctx */
@@ -193,7 +193,7 @@ export function flashTerminalWidget(ctx, state, taskId, reason) {
     setTimeout(() => {
         try {
             ctx.ui.setWidget(WIDGET_KEY, undefined);
-            publishWidget(WIDGET_KEY, undefined);
+            setTaskWidget(undefined);
         }
         catch {
             /* stale ctx */

package/dist/workers/html-clean.js

@@ -1,3 +1,6 @@
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 import { JSDOM } from 'jsdom';
 import { Readability } from '@mozilla/readability';
 import TurndownService from 'turndown';
@@ -29,8 +32,57 @@ export function cleanHtml(html, baseUrl) {
 }
 const DEFAULT_TIMEOUT_MS = 15_000;
 const DEFAULT_MAX_BYTES = 2 * 1024 * 1024; // 2 MB
-const PKG_VERSION = '0.2.0'; // bump in lockstep with package.json on release
+const PKG_VERSION = readPkgVersion();
 const USER_AGENT = `pi-worker/${PKG_VERSION} (+https://npmjs.com/package/@mjasnikovs/pi-worker)`;
+// Read the version from package.json at runtime so the User-Agent never drifts
+// out of sync with releases. Two levels up holds for both src/workers (tests)
+// and dist/workers (build) since tsc preserves the layout under rootDir.
+function readPkgVersion() {
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const pkg = JSON.parse(readFileSync(join(here, '..', '..', 'package.json'), 'utf8'));
+        return typeof pkg.version === 'string' ? pkg.version : '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}
+// Decide how to handle a response based on its content-type. HTML is run through
+// the readability/turndown pipeline; text-ish formats (markdown, plain text,
+// JSON, XML/feeds) are already clean and pass through verbatim; binary formats
+// (PDF, images, octet-stream, …) are rejected. A missing content-type is treated
+// as text — many plain-text endpoints (llms.txt, robots.txt) omit the header.
+function classifyContentType(contentType) {
+    const mime = contentType.split(';')[0].trim().toLowerCase();
+    if (mime === '')
+        return 'text';
+    if (mime === 'text/html' || mime === 'application/xhtml+xml')
+        return 'html';
+    if (mime.startsWith('text/'))
+        return 'text';
+    if (mime === 'application/json' || mime.endsWith('+json'))
+        return 'text';
+    if (mime === 'application/xml' || mime.endsWith('+xml'))
+        return 'text';
+    if (mime === 'application/javascript' || mime === 'application/ecmascript')
+        return 'text';
+    return 'reject';
+}
+// Extract the charset from a content-type header, if present and supported by
+// TextDecoder; otherwise fall back to UTF-8 so non-UTF-8 pages aren't mangled.
+function decoderFor(contentType) {
+    const match = /charset=([^;]+)/i.exec(contentType);
+    const charset = match?.[1]?.trim().replace(/^["']|["']$/g, '');
+    if (charset) {
+        try {
+            return new TextDecoder(charset, { fatal: false });
+        }
+        catch {
+            // Unknown/unsupported label — fall through to UTF-8.
+        }
+    }
+    return new TextDecoder('utf-8', { fatal: false });
+}
 export class FetchAndCleanError extends Error {
     kind;
     cause;
@@ -77,15 +129,16 @@ export async function fetchAndClean(url, opts = {}) {
             throw new FetchAndCleanError(`Fetch failed: HTTP ${response.status} ${response.statusText} for ${url}`, 'http-error');
         }
         const contentType = response.headers.get('content-type') ?? '';
-        if (!contentType.toLowerCase().includes('text/html')) {
-            throw new FetchAndCleanError(`${url} is ${contentType || 'unknown content type'}, not HTML. pi-worker-fetch only reads HTML pages.`, 'not-html');
+        const kind = classifyContentType(contentType);
+        if (kind === 'reject') {
+            throw new FetchAndCleanError(`${url} is ${contentType || 'unknown content type'}, not a text or HTML page that pi-worker-fetch can read.`, 'not-html');
         }
         const reader = response.body?.getReader();
         if (!reader) {
             throw new FetchAndCleanError(`Could not fetch ${url}: empty response body`, 'network');
         }
-        const decoder = new TextDecoder('utf-8', { fatal: false });
-        let html = '';
+        const decoder = decoderFor(contentType);
+        let text = '';
         let bytesRead = 0;
         try {
             while (true) {
@@ -99,10 +152,10 @@ export async function fetchAndClean(url, opts = {}) {
                         internalController.abort();
                         break;
                     }
-                    html += decoder.decode(value, { stream: true });
+                    text += decoder.decode(value, { stream: true });
                 }
             }
-            html += decoder.decode();
+            text += decoder.decode();
         }
         catch (err) {
             if (sizeExceeded) {
@@ -119,8 +172,15 @@ export async function fetchAndClean(url, opts = {}) {
             throw new FetchAndCleanError(`${url} exceeds ${formatBytes(maxBytes)} size cap. Try a more specific URL.`, 'too-large');
         }
         const finalUrl = response.url || url;
-        const cleaned = cleanHtml(html, finalUrl);
-        return cleaned;
+        if (kind === 'html') {
+            return cleanHtml(text, finalUrl);
+        }
+        // text-ish formats are already clean — return them verbatim.
+        return {
+            title: hostnameOf(finalUrl),
+            markdown: text.trim(),
+            finalUrl
+        };
     }
     finally {
         clearTimeout(timeoutHandle);
@@ -128,6 +188,14 @@ export async function fetchAndClean(url, opts = {}) {
             opts.signal.removeEventListener('abort', onUserAbort);
     }
 }
+function hostnameOf(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return url;
+    }
+}
 function describeError(err) {
     if (err instanceof Error)
         return err.message;

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

@@ -20,17 +20,20 @@ export function registerPiWorkerDocs(pi, internals = {}) {
     pi.registerTool({
         name: 'pi-worker-docs',
         label: 'Pi Worker Docs',
-        description: 'Look up an npm package locally and return a focused, version-pinned '
-            + 'answer extracted from its .d.ts types and README. No network after install (except a small '
-            + 'live npm registry call described below). The cache lives at ~/.cache/pi-worker/docs.sqlite '
-            + 'and is keyed by exact installed version.\n'
-            + 'If the package is not yet installed, it is installed automatically via bun add or npm install.\n'
-            + '\n'
-            + 'Live registry data: in addition to the docs answer, the tool fetches the latest published '
-            + 'version, recent versions, and publish date from the npm registry and prepends them to the '
-            + 'output (and exposes them in details). This is the source of truth for "what is the latest '
-            + 'version of X" questions — training-data versions are typically months stale. The lookup is '
-            + 'best-effort and silently absent when offline.\n'
+        description: 'Look up an INSTALLED npm package and return a focused, version-pinned '
+            + 'answer from its .d.ts types and README, PLUS the latest published version '
+            + 'from a live npm registry call. USE THIS BEFORE ANSWERING any question '
+            + 'about how to use a library, what it exports, its types/overloads/config, '
+            + 'or the latest published version of an npm package. Do NOT answer package '
+            + 'APIs from memory, do NOT run `npm view`/bash to get a package version, and '
+            + 'do NOT web-search for an installed package — this tool is the source of '
+            + 'truth and is version-pinned to what is actually installed (training-data '
+            + 'versions and APIs are typically months stale).\n'
+            + 'For a non-package framework/runtime version (e.g. Node.js, Ubuntu), use '
+            + '`pi-worker-search` instead. If the package is not installed it is '
+            + 'auto-installed via bun add or npm install. The cache lives at '
+            + '~/.cache/pi-worker/docs.sqlite, keyed by exact installed version; the '
+            + 'registry lookup is best-effort and silently absent when offline.\n'
             + '\n'
             + 'Good fits:\n'
             + '- "What does library X export?" / "How does function Y work?"\n'

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

@@ -14,10 +14,11 @@ export function registerPiWorkerFetch(pi, internals = {}) {
     pi.registerTool({
         name: 'pi-worker-fetch',
         label: 'Pi Worker Fetch',
-        description: 'Fetch an HTML page, clean it to markdown, and hand it to an isolated '
-            + 'child Pi session that extracts ONLY content answering `query`. '
-            + 'Returns the focused answer. Use after `pi-worker-search` (or with a '
-            + 'known URL) to avoid stuffing raw HTML into the main context.',
+        description: 'Fetch a web page or text resource (HTML, markdown, plain text, JSON, '
+            + 'XML/feeds), clean HTML to markdown, and hand it to an isolated child '
+            + 'Pi session that extracts ONLY content answering `query`. Returns the '
+            + 'focused answer. Use after `pi-worker-search` (or with a known URL) to '
+            + 'avoid stuffing raw content into the main context.',
         parameters: Params,
         executionMode: 'parallel',
         async execute(_toolCallId, params, signal, _onUpdate, ctx) {

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

@@ -14,9 +14,14 @@ export function registerPiWorkerSearch(pi, internals = {}) {
     pi.registerTool({
         name: 'pi-worker-search',
         label: 'Pi Worker Search',
-        description: 'Search the web via Brave Search. Returns a compact markdown list of '
-            + 'up to 10 results (title, URL, snippet). Use this to find candidate '
-            + 'URLs, then call `pi-worker-fetch` on the URL you want to read. '
+        description: 'Search the live web via Brave Search. CALL THIS BEFORE ANSWERING any '
+            + 'question about current or version-specific external facts: '
+            + 'library/framework versions and their APIs, latest releases, recently '
+            + 'shipped features, current events, prices, or who currently holds a '
+            + 'role. Your built-in knowledge is out of date — do NOT answer such '
+            + 'questions from memory and do NOT shell out with bash to guess. Returns '
+            + 'a compact markdown list of up to 10 results (title, URL, snippet); then '
+            + 'call `pi-worker-fetch` on the URL you want to read. '
             + 'Requires BRAVE_SEARCH_API_KEY env var.',
         parameters: Params,
         executionMode: 'parallel',

package/dist/workers/pi-worker.js

@@ -18,16 +18,19 @@ export function registerPiWorker(pi) {
     pi.registerTool({
         name: 'pi-worker',
         label: 'Pi Worker',
-        description: 'Dispatch an isolated child Pi to investigate a question and return its '
-            + 'conclusion — not the raw evidence. Use when answering requires reading '
-            + 'multiple files, running several greps, or scanning large command output '
-            + 'you do not need verbatim.\n'
+        description: 'Dispatch an isolated child Pi to investigate and return its CONCLUSION — '
+            + 'not the raw evidence. USE THIS FIRST, instead of running your own '
+            + 'ls/grep/find/read, whenever a question spans MULTIPLE files or means '
+            + 'searching/scanning code you have not already located. Doing it yourself '
+            + 'floods your context with raw file output; the worker reads in isolation '
+            + 'and returns only the answer. You can dispatch several in one turn for '
+            + 'independent questions.\n'
             + '\n'
             + 'Good fits:\n'
             + '- "Where/how is X handled in this repo?" across unfamiliar code\n'
             + '- Audits and pattern scans across many files ("every place we log PII")\n'
-            + '- Summarising long test output, logs, or shell output\n'
-            + '- Parallel fan-out: dispatch several workers in one turn for independent questions\n'
+            + '- Tracing a flow across layers (router → service → database)\n'
+            + '- Summarising long test output, logs, or shell output you do not need verbatim\n'
             + '\n'
             + 'Skip when:\n'
             + '- You already know the exact file — call `read` directly\n'

package/package.json

@@ -1,12 +1,13 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.7.0",
+    "version": "0.7.2",
     "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",
     "types": "./dist/index.d.ts",
     "files": [
         "dist",
+        "assets",
         "README.md",
         "LICENSE"
     ],