@mjasnikovs/pi-task 0.13.6 → 0.13.8

package/dist/task/spec-validation.js

@@ -0,0 +1,90 @@
+/**
+ * Spec gate — the guards that decide whether a composed spec is acceptable at
+ * handoff. Unlike the informational parsers in parsers.ts, these answer a
+ * yes/no (or "what's wrong") question the orchestrator and critique phase act
+ * on: is the VERIFY block runnable, is the shape well-formed, did critique come
+ * back CLEAN. Self-contained (no imports) so the gate doesn't drag in the phase
+ * pipeline.
+ */
+// ─── Verify block parser ─────────────────────────────────────────────────────
+export function parseVerifyBlock(spec) {
+    const lines = spec.split('\n');
+    let i = 0;
+    while (i < lines.length && !/^VERIFY:\s*$/.test(lines[i]))
+        i++;
+    if (i >= lines.length)
+        return null;
+    i++;
+    while (i < lines.length && lines[i].trim() === '')
+        i++;
+    if (i >= lines.length)
+        return null;
+    if (!/^```(sh|bash)?\s*$/.test(lines[i]))
+        return null;
+    i++;
+    const cmds = [];
+    while (i < lines.length && !/^```\s*$/.test(lines[i])) {
+        const line = lines[i].trim();
+        if (line.length > 0 && !line.startsWith('#'))
+            cmds.push({ raw: line });
+        i++;
+    }
+    return cmds;
+}
+// ─── Critique triage gate ────────────────────────────────────────────────────
+// The critique-triage prompt instructs the worker to emit the literal token
+// `CLEAN` on its own line when the compose draft has no substantive defects, so
+// we can skip the expensive full-rewrite pass. Anything else is treated as a
+// defect list that gets fed into the rewrite. Empty output is NOT clean — that
+// would be a silent crash, and treating it as clean would skip review entirely.
+export function isCritiqueClean(text) {
+    const firstLine = text
+        .split('\n')
+        .map(l => l.trim())
+        .find(l => l.length > 0);
+    if (!firstLine)
+        return false;
+    return /^CLEAN[.!]?$/i.test(firstLine);
+}
+// ─── Spec shape gate ─────────────────────────────────────────────────────────
+/**
+ * Drop any preamble the model emitted before the spec's GOAL header. The
+ * thinking model sometimes narrates ("Now I have all the context. Here's the
+ * rewritten spec:") before GOAL — the prompts forbid it, but the critique
+ * validator only checks for a VERIFY block, so it leaked into the delivered
+ * spec. We slice from the first line that begins a GOAL section so the spec
+ * starts at GOAL. No GOAL line → returned unchanged (validation then flags it).
+ */
+export function stripSpecPreamble(spec) {
+    const lines = spec.split('\n');
+    const idx = lines.findIndex(l => /^GOAL\b/i.test(l));
+    if (idx <= 0)
+        return spec;
+    // Only strip plain narration. If the lead-in is a markdown fence or a
+    // cat-heredoc wrapper, leave it untouched — that's a malformation
+    // validateSpecShape must reject (and compose must retry on), not something
+    // to silently unwrap into a passing spec.
+    const preamble = lines.slice(0, idx);
+    if (preamble.some(l => /^\s*```/.test(l) || /^\s*cat\s*<</.test(l)))
+        return spec;
+    return lines.slice(idx).join('\n');
+}
+export function validateSpecShape(spec) {
+    const trimmed = spec.trim();
+    if (trimmed.length === 0)
+        return 'spec is empty';
+    const firstLine = trimmed.split('\n', 1)[0];
+    if (/^\s*```/.test(firstLine))
+        return 'spec starts with a markdown fence';
+    if (/^\s*cat\s*<<\s*['"]?[A-Za-z_][A-Za-z0-9_]*['"]?/.test(firstLine)) {
+        return 'spec is wrapped in a cat heredoc';
+    }
+    if (!/^GOAL\b/i.test(trimmed))
+        return 'spec does not start with GOAL';
+    for (const section of ['CONSTRAINTS', 'ACCEPTANCE', 'VERIFY']) {
+        if (!new RegExp(`^\\s*${section}\\b`, 'm').test(trimmed)) {
+            return `spec missing required section: ${section}`;
+        }
+    }
+    return null;
+}

package/dist/task/widget.d.ts

@@ -5,7 +5,7 @@
  * context usage, and the latest child-process line.
  */
 import type { ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
-import { type PhaseName, type TaskState } from './task-file.js';
+import { type PhaseName, type TaskState } from './task-types.js';
 export interface WidgetState {
     taskId: string;
     title: string;

package/dist/task/widget.js

@@ -4,7 +4,7 @@
  * Renders a live-updating status block showing task id, phase, elapsed time,
  * context usage, and the latest child-process line.
  */
-import { PHASE_INDEX, PHASE_ORDER } from './task-file.js';
+import { PHASE_INDEX, PHASE_ORDER } from './task-types.js';
 import { setTaskWidget } from '../remote/session-state.js';
 // ─── Constants ───────────────────────────────────────────────────────────────
 export const WIDGET_KEY = 'pi-tasks';

package/dist/workers/html-clean.js

@@ -11,21 +11,22 @@ const turndown = new TurndownService({
 });
 export function cleanHtml(html, baseUrl) {
     const { document } = parseHTML(html);
+    const doc = document;
     const reader = new Readability(document);
     const parsed = reader.parse();
     if (parsed && parsed.content) {
         return {
-            title: parsed.title || document.title || new URL(baseUrl).hostname,
+            title: parsed.title || doc.title || new URL(baseUrl).hostname,
             markdown: turndown.turndown(parsed.content).trim(),
             finalUrl: baseUrl
         };
     }
     // Fallback: turndown the body
-    const body = document.body;
+    const body = doc.body;
     const bodyHtml = body ? body.innerHTML : '';
     const markdown = turndown.turndown(bodyHtml).trim();
     return {
-        title: document.title || new URL(baseUrl).hostname,
+        title: doc.title || new URL(baseUrl).hostname,
         markdown,
         finalUrl: baseUrl
     };
@@ -147,7 +148,9 @@ export async function fetchAndClean(url, opts = {}) {
         let bytesRead = 0;
         try {
             while (true) {
-                const { value, done } = await reader.read();
+                // response.body's stream type doesn't resolve here, so the chunk
+                // surfaces as `any`; pin it to the Uint8Array the reader yields.
+                const { value, done } = (await reader.read());
                 if (done)
                     break;
                 if (value) {

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

@@ -7,7 +7,7 @@ import { formatNpmVersionSection } from './npm-version.js';
 import { runChild, CHILD_BASE_ARGS } from '../shared/child-process.js';
 import { parseChildOutput, isExcerptInContent } from '../shared/child-output.js';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 import { projectDocsRaw, buildProjectPrompt } from './docs-project.js';
 const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
 const RENDER_QUERY_MAX = 100;
@@ -20,7 +20,7 @@ const Params = Type.Object({
     })
 });
 export function registerPiWorkerDocs(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-docs',
         label: 'Pi Worker Docs',
         description: 'Look up an INSTALLED npm package and return a focused, version-pinned '
@@ -56,8 +56,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
             + 'Skip when:\n'
             + '- You need docs for a specific newer version than what is installed — use pi-worker-fetch on the upstream docs site',
         parameters: Params,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async run(params, signal, ctx) {
             const spawn = internals.spawn
                 ?? (globalThis.Bun !== undefined ?
                     globalThis.Bun.spawn
@@ -74,18 +73,24 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     cacheError = err instanceof Error ? err.message : String(err);
                 }
                 if (!cache) {
-                    return textResult(`Project docs unavailable: cache open failed (${cacheError}).`, {});
+                    return {
+                        text: `Project docs unavailable: cache open failed (${cacheError}).`,
+                        details: {}
+                    };
                 }
                 const retrieveChunks = internals.retrieveChunks ?? defaultRetrieveChunks;
                 const projectResult = projectDocsRaw(cache, ctx.cwd, params.query, retrieveChunks);
                 if (projectResult.kind === 'error') {
-                    return textResult(`Project docs error: ${projectResult.message}`, {});
+                    return { text: `Project docs error: ${projectResult.message}`, details: {} };
                 }
                 if (projectResult.kind === 'no_chunks') {
-                    return textResult(`Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`, {
-                        hitCache: projectResult.hitCache,
-                        indexedFiles: projectResult.filesIngested
-                    });
+                    return {
+                        text: `Project "${projectResult.projectName}" has no .ts/.tsx files indexed.`,
+                        details: {
+                            hitCache: projectResult.hitCache,
+                            indexedFiles: projectResult.filesIngested
+                        }
+                    };
                 }
                 const { projectName, chunks, hitCache, filesIngested, indexingMs } = projectResult;
                 const baseDetails = {
@@ -98,19 +103,16 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 const prompt = buildProjectPrompt(projectName, params.query, concatenated);
                 const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
                 const child = await runChild(spawn, invocation, ctx.cwd, signal);
-                if (child.aborted) {
-                    return textResult('Project docs lookup aborted.', {
-                        ...baseDetails,
-                        aborted: true,
-                        childExitCode: child.exitCode
-                    });
-                }
-                if (child.exitCode !== 0) {
-                    const tail = child.stderr.trim().slice(-500) || '(no stderr)';
-                    return textResult(`Worker exited ${child.exitCode}.\n${tail}`, {
-                        ...baseDetails,
-                        childExitCode: child.exitCode
-                    });
+                const failure = formatChildFailure(child, 'Project docs lookup aborted.');
+                if (failure !== null) {
+                    return {
+                        text: failure,
+                        details: {
+                            ...baseDetails,
+                            ...(child.aborted ? { aborted: true } : {}),
+                            childExitCode: child.exitCode
+                        }
+                    };
                 }
                 const parsed = parseChildOutput(child.stdout);
                 const verified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;
@@ -121,11 +123,14 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     entryDts: null,
                     readme: null
                 }, parsed, verified);
-                return textResult(text, {
-                    ...baseDetails,
-                    childExitCode: 0,
-                    excerptVerified: verified
-                });
+                return {
+                    text,
+                    details: {
+                        ...baseDetails,
+                        childExitCode: 0,
+                        excerptVerified: verified
+                    }
+                };
             }
             // ── npm package lookup (existing path) ──────────────────────────
             const rawResult = await docsRaw({
@@ -157,22 +162,28 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                     autoInstalled: rawResult.autoInstalled,
                     ...npmDetails
                 };
-                return textResult(npmHeader + rawResult.message, details);
+                return { text: npmHeader + rawResult.message, details };
             }
             if (rawResult.kind === 'not_installed') {
-                return textResult(npmHeader
-                    + `Package "${rawResult.pkg}" is not installed and auto-install failed.`, { resolveError: 'not_installed', ...npmDetails });
+                return {
+                    text: npmHeader
+                        + `Package "${rawResult.pkg}" is not installed and auto-install failed.`,
+                    details: { resolveError: 'not_installed', ...npmDetails }
+                };
             }
             if (rawResult.kind === 'no_chunks') {
-                return textResult(npmHeader
-                    + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`, {
-                    version: rawResult.pkg.version,
-                    hitCache: rawResult.hitCache,
-                    indexedFiles: rawResult.indexedFiles ?? 0,
-                    cacheError: rawResult.cacheError,
-                    autoInstalled: rawResult.autoInstalled,
-                    ...npmDetails
-                });
+                return {
+                    text: npmHeader
+                        + `Package ${rawResult.pkg.name}@${rawResult.pkg.version} has no .d.ts files or README. Use pi-worker to read source directly.`,
+                    details: {
+                        version: rawResult.pkg.version,
+                        hitCache: rawResult.hitCache,
+                        indexedFiles: rawResult.indexedFiles ?? 0,
+                        cacheError: rawResult.cacheError,
+                        autoInstalled: rawResult.autoInstalled,
+                        ...npmDetails
+                    }
+                };
             }
             // kind === 'ok'
             const { pkg, chunks, hitCache, indexingMs, cacheError, autoInstalled } = rawResult;
@@ -189,28 +200,28 @@ export function registerPiWorkerDocs(pi, internals = {}) {
             const prompt = buildPrompt(pkg, params.query, concatenated);
             const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
             const child = await runChild(spawn, invocation, ctx.cwd, signal);
-            if (child.aborted) {
-                return textResult(npmHeader + 'Docs lookup aborted.', {
-                    ...baseDetails,
-                    aborted: true,
-                    childExitCode: child.exitCode
-                });
-            }
-            if (child.exitCode !== 0) {
-                const tail = child.stderr.trim().slice(-500) || '(no stderr)';
-                return textResult(npmHeader + `Worker exited ${child.exitCode}.\n${tail}`, {
-                    ...baseDetails,
-                    childExitCode: child.exitCode
-                });
+            const failure = formatChildFailure(child, 'Docs lookup aborted.');
+            if (failure !== null) {
+                return {
+                    text: npmHeader + failure,
+                    details: {
+                        ...baseDetails,
+                        ...(child.aborted ? { aborted: true } : {}),
+                        childExitCode: child.exitCode
+                    }
+                };
             }
             const parsed = parseChildOutput(child.stdout);
             const verified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;
             const text = npmHeader + formatResultText(pkg, parsed, verified);
-            return textResult(text, {
-                ...baseDetails,
-                childExitCode: 0,
-                excerptVerified: verified
-            });
+            return {
+                text,
+                details: {
+                    ...baseDetails,
+                    childExitCode: 0,
+                    excerptVerified: verified
+                }
+            };
         },
         renderCall(args, theme) {
             const query = args.query.replace(/\s+/g, ' ').trim();

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

@@ -2,7 +2,7 @@ import { Type } from '@sinclair/typebox';
 import { Text } from '@earendil-works/pi-tui';
 import { FetchAndCleanError } from './html-clean.js';
 import { fetchFocused, formatResultText } from './fetch-core.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 const RENDER_QUERY_MAX = 100;
 const Params = Type.Object({
     url: Type.String({ description: 'URL to fetch. Must be http or https.' }),
@@ -11,7 +11,7 @@ const Params = Type.Object({
     })
 });
 export function registerPiWorkerFetch(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-fetch',
         label: 'Pi Worker Fetch',
         description: 'Fetch a web page or text resource (HTML, markdown, plain text, JSON, '
@@ -20,13 +20,12 @@ export function registerPiWorkerFetch(pi, internals = {}) {
             + '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) {
+        async run(params, signal, ctx) {
             try {
                 new URL(params.url);
             }
             catch {
-                return textResult(`Invalid URL: ${params.url}`, {});
+                return { text: `Invalid URL: ${params.url}`, details: {} };
             }
             try {
                 const result = await fetchFocused({
@@ -37,28 +36,33 @@ export function registerPiWorkerFetch(pi, internals = {}) {
                     fetchAndClean: internals.fetchAndClean,
                     spawn: internals.spawn
                 });
-                if (result.aborted) {
-                    return textResult('Fetch aborted.', { childExitCode: result.childExitCode });
-                }
-                if (result.childExitCode !== 0) {
-                    const tail = result.stderr.trim().slice(-500) || '(no stderr)';
-                    return textResult(`Worker exited ${result.childExitCode}.\n${tail}`, {
-                        childExitCode: result.childExitCode
-                    });
+                const failure = formatChildFailure({
+                    aborted: result.aborted,
+                    exitCode: result.childExitCode,
+                    stderr: result.stderr
+                }, 'Fetch aborted.');
+                if (failure !== null) {
+                    return { text: failure, details: { childExitCode: result.childExitCode } };
                 }
                 const text = formatResultText({ answer: result.answer, excerpt: result.excerpt }, result.excerptVerified) || '(no output)';
-                return textResult(text, {
-                    childExitCode: 0,
-                    answer: result.answer,
-                    excerpt: result.excerpt,
-                    excerptVerified: result.excerptVerified
-                });
+                return {
+                    text,
+                    details: {
+                        childExitCode: 0,
+                        answer: result.answer,
+                        excerpt: result.excerpt,
+                        excerptVerified: result.excerptVerified
+                    }
+                };
             }
             catch (err) {
                 if (err instanceof FetchAndCleanError) {
-                    return textResult(err.message, {});
+                    return { text: err.message, details: {} };
                 }
-                return textResult(`Could not fetch ${params.url}: ${err instanceof Error ? err.message : String(err)}`, {});
+                return {
+                    text: `Could not fetch ${params.url}: ${err instanceof Error ? err.message : String(err)}`,
+                    details: {}
+                };
             }
         },
         renderCall(args, theme) {

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

@@ -1,7 +1,7 @@
 import { Type } from '@sinclair/typebox';
 import { Text } from '@earendil-works/pi-tui';
 import { search } from './search-core.js';
-import { textResult } from './shared.js';
+import { makeWorkerTool } from './shared.js';
 const Params = Type.Object({
     query: Type.String({ description: 'Search query.' }),
     count: Type.Optional(Type.Integer({
@@ -11,7 +11,7 @@ const Params = Type.Object({
     }))
 });
 export function registerPiWorkerSearch(pi, internals = {}) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker-search',
         label: 'Pi Worker Search',
         description: 'Search the live web via Brave Search. CALL THIS BEFORE ANSWERING any '
@@ -24,8 +24,7 @@ export function registerPiWorkerSearch(pi, internals = {}) {
             + 'call `pi-worker-fetch` on the URL you want to read. '
             + 'Requires BRAVE_SEARCH_API_KEY env var.',
         parameters: Params,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal) {
+        async run(params, signal) {
             const result = await search({
                 query: params.query,
                 count: params.count,
@@ -33,20 +32,15 @@ export function registerPiWorkerSearch(pi, internals = {}) {
                 getEnv: internals.getEnv,
                 braveSearch: internals.braveSearch
             });
-            if (result.kind === 'no_key') {
-                return textResult(result.message, { resultCount: 0 });
-            }
-            if (result.kind === 'error') {
-                return textResult(result.message, { resultCount: 0 });
+            if (result.kind === 'no_key' || result.kind === 'error') {
+                return { text: result.message, details: { resultCount: 0 } };
             }
             const { results } = result;
             if (results.length === 0) {
-                return textResult(`No results for: ${params.query}`, {
-                    resultCount: 0
-                });
+                return { text: `No results for: ${params.query}`, details: { resultCount: 0 } };
             }
             const lines = results.map((r, i) => `${i + 1}. [${r.title}](${r.url}) — ${r.description}`);
-            return textResult(lines.join('\n'), { resultCount: results.length });
+            return { text: lines.join('\n'), details: { resultCount: results.length } };
         },
         renderCall(args, theme) {
             let text = theme.fg('toolTitle', theme.bold('pi-worker-search '));

package/dist/workers/pi-worker.js

@@ -9,13 +9,13 @@
 import { Text } from '@earendil-works/pi-tui';
 import { Type } from '@sinclair/typebox';
 import { runWorker } from './pi-worker-core.js';
-import { textResult } from './shared.js';
+import { formatChildFailure, makeWorkerTool } from './shared.js';
 const RENDER_PROMPT_MAX = 120;
 const WorkerParams = Type.Object({
     prompt: Type.String({ description: 'Task for the worker to perform.' })
 });
 export function registerPiWorker(pi) {
-    pi.registerTool({
+    makeWorkerTool(pi, {
         name: 'pi-worker',
         label: 'Pi Worker',
         description: 'Dispatch an isolated child Pi to investigate and return its CONCLUSION — '
@@ -37,19 +37,13 @@ export function registerPiWorker(pi) {
             + '- The task needs writes/edits (worker is read-only)\n'
             + '- The task needs the web — use `pi-worker-search` / `pi-worker-fetch`',
         parameters: WorkerParams,
-        executionMode: 'parallel',
-        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+        async run(params, signal, ctx) {
             const result = await runWorker({ prompt: params.prompt, cwd: ctx.cwd, signal });
-            if (result.aborted) {
-                return textResult('Worker aborted.', { exitCode: result.exitCode });
-            }
-            if (result.exitCode !== 0) {
-                const tail = result.stderr.slice(-500) || '(no stderr)';
-                return textResult(`Worker exited ${result.exitCode}.\n${tail}`, {
-                    exitCode: result.exitCode
-                });
-            }
-            return textResult(result.text || '(no output)', { exitCode: result.exitCode });
+            const details = { exitCode: result.exitCode };
+            const failure = formatChildFailure(result, 'Worker aborted.');
+            if (failure !== null)
+                return { text: failure, details };
+            return { text: result.text || '(no output)', details };
         },
         renderCall(args, theme) {
             const prompt = args.prompt.replace(/\s+/g, ' ').trim();

package/dist/workers/shared.d.ts

@@ -1,3 +1,43 @@
+import type { Static, TSchema } from '@sinclair/typebox';
 import type { AgentToolResult } from '@earendil-works/pi-agent-core';
+import type { ExtensionAPI, ExtensionContext, Theme } from '@earendil-works/pi-coding-agent';
+import type { Text } from '@earendil-works/pi-tui';
 /** Build a plain-text AgentToolResult. */
 export declare function textResult<T>(text: string, details: T): AgentToolResult<T>;
+/**
+ * The slice of a child-process result a worker needs to decide failure.
+ * `exitCode` is normalised here — `fetch-core` exposes it as `childExitCode`,
+ * the others as `exitCode`; callers map to this single name.
+ */
+export interface ChildOutcome {
+    aborted: boolean;
+    exitCode: number;
+    stderr: string;
+}
+/**
+ * The one place worker child-failure is turned into a user-facing message.
+ * Returns `null` when the child succeeded (caller proceeds to format output),
+ * otherwise the standard abort/exit message. Concentrating this here keeps the
+ * stderr-tail rule identical across every worker — it had already drifted
+ * (`pi-worker` skipped the `.trim()` the others applied).
+ */
+export declare function formatChildFailure(child: ChildOutcome, abortedMessage: string): string | null;
+/**
+ * What a worker tool is, minus the registration ritual: a name/label/schema,
+ * a `run` that produces the focused text + structured details, and a `renderCall`
+ * for the TUI. `makeWorkerTool` owns `registerTool`, the parallel execution mode,
+ * and wrapping the result in `textResult`.
+ */
+export interface WorkerToolSpec<TParams extends TSchema, TDetails> {
+    name: string;
+    label: string;
+    description: string;
+    parameters: TParams;
+    run(params: Static<TParams>, signal: AbortSignal | undefined, ctx: ExtensionContext): Promise<{
+        text: string;
+        details: TDetails;
+    }>;
+    renderCall(args: Static<TParams>, theme: Theme): Text;
+}
+/** Register a worker tool from its spec, supplying the shared registration ritual. */
+export declare function makeWorkerTool<TParams extends TSchema, TDetails>(pi: ExtensionAPI, spec: WorkerToolSpec<TParams, TDetails>): void;

package/dist/workers/shared.js

@@ -2,3 +2,34 @@
 export function textResult(text, details) {
     return { content: [{ type: 'text', text }], details };
 }
+/**
+ * The one place worker child-failure is turned into a user-facing message.
+ * Returns `null` when the child succeeded (caller proceeds to format output),
+ * otherwise the standard abort/exit message. Concentrating this here keeps the
+ * stderr-tail rule identical across every worker — it had already drifted
+ * (`pi-worker` skipped the `.trim()` the others applied).
+ */
+export function formatChildFailure(child, abortedMessage) {
+    if (child.aborted)
+        return abortedMessage;
+    if (child.exitCode !== 0) {
+        const tail = child.stderr.trim().slice(-500) || '(no stderr)';
+        return `Worker exited ${child.exitCode}.\n${tail}`;
+    }
+    return null;
+}
+/** Register a worker tool from its spec, supplying the shared registration ritual. */
+export function makeWorkerTool(pi, spec) {
+    pi.registerTool({
+        name: spec.name,
+        label: spec.label,
+        description: spec.description,
+        parameters: spec.parameters,
+        executionMode: 'parallel',
+        async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+            const { text, details } = await spec.run(params, signal, ctx);
+            return textResult(text, details);
+        },
+        renderCall: (args, theme) => spec.renderCall(args, theme)
+    });
+}

package/package.json

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