@mjasnikovs/pi-task 0.18.12 → 0.18.13

package/dist/config/config.d.ts

@@ -30,6 +30,23 @@ export interface PiTaskConfig {
      * DEFAULT `exa` so search works out of the box with zero configuration.
      */
     searchProvider: SearchProvider;
+    /**
+     * Absolute entry-point paths of host pi extensions to load into every child
+     * pi session via explicit `-e` flags (GitHub issue #4: a provider registered
+     * by an extension — e.g. pi-lmstudio — otherwise doesn't exist in children,
+     * which then can't resolve the default model and demand OAuth/API keys).
+     * Children keep `--no-extensions`, so discovery stays off and ONLY these
+     * load — the whitelist is strictly additive. Entries whose file no longer
+     * exists (extension uninstalled) are skipped at spawn time, never fatal.
+     * DEFAULT empty: child isolation is unchanged until the user opts in via
+     * /task-config, which enumerates the currently installed extensions.
+     */
+    extensionWhitelist: string[];
 }
+/**
+ * A hand-edited config can hold anything; keep only string entries so a stray
+ * object/number can't reach the child argv as `-e [object Object]`.
+ */
+export declare function sanitizeExtensionWhitelist(value: unknown): string[];
 export declare function getConfig(): PiTaskConfig;
 export declare function saveConfig(config: PiTaskConfig): Promise<void>;

package/dist/config/config.js

@@ -14,8 +14,18 @@ const DEFAULTS = {
     // ON: the F10 live A/B showed no answer-quality regression (fidelity 3/3, quality
     // 3/3, 0 collisions; ~14.5s of repeated docs lookups collapse to 0ms on a hit).
     researchCache: true,
-    searchProvider: 'exa'
+    searchProvider: 'exa',
+    extensionWhitelist: []
 };
+/**
+ * A hand-edited config can hold anything; keep only string entries so a stray
+ * object/number can't reach the child argv as `-e [object Object]`.
+ */
+export function sanitizeExtensionWhitelist(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((p) => typeof p === 'string' && p.trim().length > 0);
+}
 const CONFIG_PATH = path.join(os.homedir(), '.config', 'pi-task', 'config.json');
 const _g = globalThis;
 if (!_g.__piTaskConfig) {
@@ -32,6 +42,7 @@ if (!G.loaded) {
         // into the dispatch switch — fall back to the default.
         if (!isSearchProvider(parsed.searchProvider))
             delete parsed.searchProvider;
+        parsed.extensionWhitelist = sanitizeExtensionWhitelist(parsed.extensionWhitelist);
         G.config = { ...DEFAULTS, ...parsed };
     }
     catch {

package/dist/config/extension-list.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Enumerates the host's installed pi extensions for the /task-config whitelist
+ * (GitHub issue #4) using pi's OWN resolver — the same DefaultPackageManager
+ * the host runtime discovers extensions with — so the menu always mirrors what
+ * `pi list`/discovery would load: install a package and it appears, uninstall
+ * it and it vanishes (a stale whitelist entry is then skipped at spawn time by
+ * extensionArgs' existence filter, never fatal).
+ */
+export interface InstalledExtension {
+    /** Absolute entry-point path — the whitelist identity AND the `-e` value. */
+    path: string;
+    /** Short display name: package name for package sources, file stem for loose files. */
+    label: string;
+    /** Provenance shown in the menu, e.g. "npm:pi-lmstudio (user)" or "discovered (user)". */
+    origin: string;
+}
+/**
+ * pi-task's own package root. Anything resolve() reports under it is pi-task
+ * itself (`dist/index.js` shows up as a discovered extension) and MUST be
+ * excluded: whitelisting pi-task into its own children would recursively boot
+ * the remote server and re-register every command in each child.
+ */
+export declare function selfPackageRoot(fromDir?: string): string;
+/** Display label for a resolved extension entry. */
+export declare function extensionLabel(entryPath: string, source: string): string;
+export interface ListInstalledOptions {
+    cwd: string;
+    /** Override for tests; defaults to the host's real agent dir (~/.pi/agent). */
+    agentDir?: string;
+    /** Override for tests; defaults to pi-task's own package root. */
+    selfRoot?: string;
+}
+/**
+ * List every extension the host pi would load, excluding pi-task itself.
+ * Only enabled entries are offered: an extension the user disabled in
+ * `pi config` shouldn't be sneaked back in through a child whitelist.
+ * Errors (unreadable settings, missing package dirs) surface as an empty
+ * list at the caller — the menu then simply shows no extension toggles.
+ */
+export declare function listInstalledExtensions(opts: ListInstalledOptions): Promise<InstalledExtension[]>;

package/dist/config/extension-list.js

@@ -0,0 +1,66 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { DefaultPackageManager, SettingsManager, getAgentDir } from '@earendil-works/pi-coding-agent';
+/**
+ * pi-task's own package root. Anything resolve() reports under it is pi-task
+ * itself (`dist/index.js` shows up as a discovered extension) and MUST be
+ * excluded: whitelisting pi-task into its own children would recursively boot
+ * the remote server and re-register every command in each child.
+ */
+export function selfPackageRoot(fromDir) {
+    let dir = fromDir ?? path.dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        if (fs.existsSync(path.join(dir, 'package.json')))
+            return dir;
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            return dir;
+        dir = parent;
+    }
+}
+function isUnder(p, root) {
+    const rel = path.relative(root, p);
+    return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
+}
+/** Display label for a resolved extension entry. */
+export function extensionLabel(entryPath, source) {
+    // Package sources keep their identity ("npm:pi-lmstudio" → "pi-lmstudio");
+    // discovered/local files read best as the file or directory stem.
+    if (source.includes(':'))
+        return source.slice(source.indexOf(':') + 1);
+    const base = path.basename(entryPath).replace(/\.(ts|js|mts|mjs|cts|cjs)$/, '');
+    return base === 'index' ? path.basename(path.dirname(entryPath)) : base;
+}
+/**
+ * List every extension the host pi would load, excluding pi-task itself.
+ * Only enabled entries are offered: an extension the user disabled in
+ * `pi config` shouldn't be sneaked back in through a child whitelist.
+ * Errors (unreadable settings, missing package dirs) surface as an empty
+ * list at the caller — the menu then simply shows no extension toggles.
+ */
+export async function listInstalledExtensions(opts) {
+    const agentDir = opts.agentDir ?? getAgentDir();
+    const selfRoot = opts.selfRoot ?? selfPackageRoot();
+    const settingsManager = SettingsManager.create(opts.cwd, agentDir);
+    const pm = new DefaultPackageManager({ cwd: opts.cwd, agentDir, settingsManager });
+    // "skip": a package in settings whose install dir is missing must not
+    // trigger an interactive install prompt from inside a config menu.
+    const resolved = await pm.resolve(() => Promise.resolve('skip'));
+    const out = [];
+    for (const r of resolved.extensions) {
+        if (!r.enabled)
+            continue;
+        const abs = path.resolve(r.path);
+        if (isUnder(abs, selfRoot))
+            continue;
+        out.push({
+            path: abs,
+            label: extensionLabel(abs, r.metadata.source),
+            origin: r.metadata.source === 'auto' ?
+                `discovered (${r.metadata.scope})`
+                : `${r.metadata.source} (${r.metadata.scope})`
+        });
+    }
+    return out;
+}

package/dist/config/register.d.ts

@@ -1,2 +1,12 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { type InstalledExtension } from './extension-list.js';
+export declare function extensionItems(extensions: InstalledExtension[], whitelist: readonly string[]): {
+    id: string;
+    label: string;
+    description: string;
+    currentValue: string;
+    values: string[];
+}[];
+/** Apply an extension toggle to the config's whitelist (idempotent both ways). */
+export declare function applyExtensionToggle(whitelist: readonly string[], entryPath: string, on: boolean): string[];
 export declare function registerConfig(pi: ExtensionAPI): void;

package/dist/config/register.js

@@ -2,6 +2,7 @@ import { SettingsList, visibleWidth } from '@earendil-works/pi-tui';
 import { registerBridgeCommand } from '../remote/bridge.js';
 import { SEARCH_PROVIDERS, SEARCH_PROVIDER_LABELS, providerForLabel } from '../workers/search-types.js';
 import { getConfig, saveConfig } from './config.js';
+import { listInstalledExtensions } from './extension-list.js';
 const CONFIG_TITLE = 'pi-task settings';
 /**
  * Frames a child component (the settings list) in a rounded border with a title
@@ -104,6 +105,29 @@ function displayValue(cfg, id, isEnum) {
         return String(cfg[id]);
     return cfg[id] ? 'on' : 'off';
 }
+/**
+ * One /task-config toggle per installed host extension (GitHub issue #4).
+ * The id carries the entry path behind a prefix so the shared onChange handler
+ * can tell an extension toggle from a PiTaskConfig field.
+ */
+const EXT_ID_PREFIX = 'ext:';
+export function extensionItems(extensions, whitelist) {
+    return extensions.map(e => ({
+        id: EXT_ID_PREFIX + e.path,
+        label: `ext: ${e.label}`,
+        description: `Also load this extension (${e.origin}) in pi-task child sessions — needed when it `
+            + 'registers the model provider the children must use (e.g. pi-lmstudio). Children '
+            + 'otherwise run with extensions off; whitelist only provider-type extensions you '
+            + `trust, since children also get its tools and hooks. ${e.path}`,
+        currentValue: whitelist.includes(e.path) ? 'on' : 'off',
+        values: ['on', 'off']
+    }));
+}
+/** Apply an extension toggle to the config's whitelist (idempotent both ways). */
+export function applyExtensionToggle(whitelist, entryPath, on) {
+    const rest = whitelist.filter(p => p !== entryPath);
+    return on ? [...rest, entryPath] : rest;
+}
 function makeTheme(theme) {
     return {
         label: (text, selected) => (selected ? theme.fg('accent', text) : text),
@@ -114,23 +138,37 @@ function makeTheme(theme) {
     };
 }
 async function handleTaskConfig(_args, ctx) {
-    const cfg = { ...getConfig() };
+    const cfg = { ...getConfig(), extensionWhitelist: [...getConfig().extensionWhitelist] };
+    // Enumerated live at open so an installed extension appears and an
+    // uninstalled one vanishes without pi-task doing any bookkeeping. A failed
+    // enumeration only costs the extension toggles, never the whole menu.
+    const installed = await listInstalledExtensions({ cwd: ctx.cwd }).catch(() => []);
     if (ctx.mode !== 'tui') {
         const lines = ITEMS.map(({ id, label, values }) => `${label.padEnd(22)} ${displayValue(cfg, id, Boolean(values))}`);
+        for (const e of installed) {
+            const state = cfg.extensionWhitelist.includes(e.path) ? 'on' : 'off';
+            lines.push(`${('ext: ' + e.label).padEnd(22)} ${state}`);
+        }
         ctx.ui.notify(lines.join('  |  '), 'info');
         return;
     }
     await ctx.ui.custom((_tui, theme, _kb, done) => {
         const listTheme = makeTheme(theme);
-        const items = ITEMS.map(({ id, label, description, values }) => ({
-            id,
-            label,
-            description,
-            currentValue: displayValue(cfg, id, Boolean(values)),
-            values: values ?? ['on', 'off']
-        }));
+        const items = [
+            ...ITEMS.map(({ id, label, description, values }) => ({
+                id: id,
+                label,
+                description,
+                currentValue: displayValue(cfg, id, Boolean(values)),
+                values: values ?? ['on', 'off']
+            })),
+            ...extensionItems(installed, cfg.extensionWhitelist)
+        ];
         const list = new SettingsList(items, 10, listTheme, (id, newValue) => {
-            if (id === 'searchProvider') {
+            if (id.startsWith(EXT_ID_PREFIX)) {
+                cfg.extensionWhitelist = applyExtensionToggle(cfg.extensionWhitelist, id.slice(EXT_ID_PREFIX.length), newValue === 'on');
+            }
+            else if (id === 'searchProvider') {
                 const provider = providerForLabel(newValue);
                 if (provider)
                     cfg.searchProvider = provider;
@@ -146,7 +184,8 @@ async function handleTaskConfig(_args, ctx) {
 }
 export function registerConfig(pi) {
     registerBridgeCommand(pi, 'task-config', {
-        description: 'Configure pi-task settings (remote, compress reasoning, auto-commit, orientation, enforce guidelines).',
+        description: 'Configure pi-task settings (remote, compress reasoning, auto-commit, orientation, '
+            + 'enforce guidelines, extension whitelist for child sessions).',
         handler: handleTaskConfig
     });
 }

package/dist/shared/child-extensions.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Extension whitelist → child argv (GitHub issue #4).
+ *
+ * Child pi sessions run with `--no-extensions`, so a provider registered by a
+ * host extension (e.g. pi-lmstudio) doesn't exist in them — the child can't
+ * resolve the default model and demands OAuth/API keys. pi's `--no-extensions`
+ * explicitly preserves explicit `-e <path>` loads (only discovery is disabled),
+ * so injecting the user's whitelisted entry paths restores the provider while
+ * keeping every non-whitelisted extension out. Same mechanism pi-task already
+ * uses for its own worker-tool extensions (see runWorker's `extensions` input).
+ */
+/**
+ * Map whitelisted entry paths to `-e` argv pairs. Pure given `exists`.
+ *
+ * A path whose file is gone (extension uninstalled since it was whitelisted)
+ * is skipped silently: pi itself would record "Extension path does not exist"
+ * as a load ERROR, and a stale toggle must never break every child spawn.
+ * Duplicates collapse so a path can't be loaded twice.
+ */
+export declare function extensionArgs(paths: readonly string[], exists?: (p: string) => boolean): string[];
+/**
+ * The base argv every child pi invocation starts from: internal worker
+ * extensions (verbatim — they always exist, shipped in dist), then the user's
+ * whitelisted extensions (existence-filtered, deduped against the internal
+ * ones), then CHILD_BASE_ARGS. Computed per spawn, not at module load, so a
+ * /task-config toggle takes effect for the next child without a restart.
+ */
+export declare function childBaseArgs(internalExtensions?: readonly string[]): string[];

package/dist/shared/child-extensions.js

@@ -0,0 +1,47 @@
+import * as fs from 'node:fs';
+import { CHILD_BASE_ARGS } from './child-process.js';
+import { getConfig } from '../config/config.js';
+/**
+ * Extension whitelist → child argv (GitHub issue #4).
+ *
+ * Child pi sessions run with `--no-extensions`, so a provider registered by a
+ * host extension (e.g. pi-lmstudio) doesn't exist in them — the child can't
+ * resolve the default model and demands OAuth/API keys. pi's `--no-extensions`
+ * explicitly preserves explicit `-e <path>` loads (only discovery is disabled),
+ * so injecting the user's whitelisted entry paths restores the provider while
+ * keeping every non-whitelisted extension out. Same mechanism pi-task already
+ * uses for its own worker-tool extensions (see runWorker's `extensions` input).
+ */
+/**
+ * Map whitelisted entry paths to `-e` argv pairs. Pure given `exists`.
+ *
+ * A path whose file is gone (extension uninstalled since it was whitelisted)
+ * is skipped silently: pi itself would record "Extension path does not exist"
+ * as a load ERROR, and a stale toggle must never break every child spawn.
+ * Duplicates collapse so a path can't be loaded twice.
+ */
+export function extensionArgs(paths, exists = fs.existsSync) {
+    const seen = new Set();
+    const args = [];
+    for (const p of paths) {
+        if (typeof p !== 'string' || p.trim().length === 0 || seen.has(p))
+            continue;
+        seen.add(p);
+        if (!exists(p))
+            continue;
+        args.push('-e', p);
+    }
+    return args;
+}
+/**
+ * The base argv every child pi invocation starts from: internal worker
+ * extensions (verbatim — they always exist, shipped in dist), then the user's
+ * whitelisted extensions (existence-filtered, deduped against the internal
+ * ones), then CHILD_BASE_ARGS. Computed per spawn, not at module load, so a
+ * /task-config toggle takes effect for the next child without a restart.
+ */
+export function childBaseArgs(internalExtensions = []) {
+    const internal = internalExtensions.flatMap(e => ['-e', e]);
+    const whitelisted = extensionArgs(getConfig().extensionWhitelist.filter(p => !internalExtensions.includes(p)));
+    return [...internal, ...whitelisted, ...CHILD_BASE_ARGS];
+}

package/dist/task/child-runner.js

@@ -7,7 +7,8 @@
  */
 import { spawn } from 'node:child_process';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { runChild as runChildUnified, CHILD_BASE_ARGS } from '../shared/child-process.js';
+import { runChild as runChildUnified } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from './loop-detector.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
 import { readSection, setTaskSection } from './task-io.js';
@@ -60,7 +61,7 @@ export function childArgs(tools) {
     // runChild below / getPiInvocation), so a large inlined-design prompt can't
     // overflow the OS command-line limit (Windows `spawn ENAMETOOLONG`).
     const toolFlags = tools === '' ? ['--no-tools'] : ['--tools', tools];
-    return [...CHILD_BASE_ARGS, '--mode', 'json', ...toolFlags];
+    return [...childBaseArgs(), '--mode', 'json', ...toolFlags];
 }
 // Sentinel error thrown when the user dismisses a grill-me dialog.
 // Defined here (not in failure-classifier.ts) to avoid circular dependency.

package/dist/workers/docs-core.js

@@ -8,7 +8,8 @@ import { resolvePackage as defaultResolvePackage, ResolveError, detectTypesRedir
 import { retrieveChunks as defaultRetrieveChunks } from './docs-retrieve.js';
 import { npmVersionLookup as defaultNpmVersionLookup } from './npm-version.js';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { CHILD_BASE_ARGS, runChild } from '../shared/child-process.js';
+import { runChild } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { parseChildOutput, isExcerptInContent, formatResultText as formatResultTextShared } from '../shared/child-output.js';
 const DEFAULT_LIMIT = 8;
 const DEFAULT_BUDGET = 24_000;
@@ -16,7 +17,7 @@ const NO_CACHE_HEAD = 25_000;
 const NO_CACHE_TAIL = 5_000;
 const NO_CACHE_TOTAL = NO_CACHE_HEAD + NO_CACHE_TAIL;
 const NO_CACHE_MARKER = '\n\n[...content continues, truncated...]\n\n';
-const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
+const childArgs = () => [...childBaseArgs(), '--no-tools'];
 export function extractParentPackage(moduleName) {
     if (moduleName.startsWith('@')) {
         const parts = moduleName.split('/');
@@ -423,7 +424,7 @@ export async function docsFocused(input) {
     const { pkg, chunks, hitCache, indexingMs } = rawResult;
     const concatenated = chunks.map(c => c.content).join('\n\n');
     const prompt = buildPrompt(pkg, input.query, concatenated);
-    const invocation = getPiInvocation([...CHILD_ARGS], prompt);
+    const invocation = getPiInvocation(childArgs(), prompt);
     const child = await runChild(spawn, invocation, input.cwd, input.signal);
     const parsed = parseChildOutput(child.stdout);
     const excerptVerified = parsed.excerpt ? isExcerptInContent(parsed.excerpt, concatenated) : undefined;

package/dist/workers/fetch-core.js

@@ -1,13 +1,14 @@
 import { spawn as defaultSpawn } from 'node:child_process';
 import { fetchAndClean as defaultFetchAndClean } from './html-clean.js';
 import { getPiInvocation } from '../shared/pi-invocation.js';
-import { CHILD_BASE_ARGS, runChild } from '../shared/child-process.js';
+import { runChild } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { parseChildOutput, isExcerptInContent, formatResultText as formatResultTextShared } from '../shared/child-output.js';
 const CONTENT_BUDGET = 30_000;
 const HEAD_CHARS = 25_000;
 const TAIL_CHARS = 5_000;
 const TRUNCATION_MARKER = '\n\n[...page continues, truncated...]\n\n';
-const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
+const childArgs = () => [...childBaseArgs(), '--no-tools'];
 export async function fetchRaw(input) {
     const fetchAndCleanFn = input.fetchAndClean ?? defaultFetchAndClean;
     const cleaned = await fetchAndCleanFn(input.url, { signal: input.signal });
@@ -24,7 +25,7 @@ export async function fetchFocused(input) {
         title: cleaned.title,
         content: truncated
     });
-    const invocation = getPiInvocation([...CHILD_ARGS], prompt);
+    const invocation = getPiInvocation(childArgs(), prompt);
     const childResult = await runChild(spawnFn, invocation, input.cwd, input.signal);
     if (childResult.aborted) {
         return {

package/dist/workers/pi-worker-core.d.ts

@@ -7,7 +7,7 @@ export interface RunWorkerInput {
     spawn?: SpawnFn;
     /** Comma-separated tool whitelist passed to `pi --tools`. Defaults to read,grep,find,ls. */
     tools?: string;
-    /** Extension entry-point paths to load via `-e <path>` before CHILD_BASE_ARGS. */
+    /** Internal extension entry-point paths to load via `-e <path>` (see childBaseArgs). */
     extensions?: string[];
     /** Called for each tool execution start and text-writing event inside the worker. */
     onLine?: (line: string) => void;

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 { runChildDefault } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { LoopDetector } from '../task/loop-detector.js';
 import { LOOP_WINDOW, LOOP_THRESHOLD, MAX_LOOP_RESTARTS, formatLoopHint } from '../task/child-runner.js';
 import { detectLeakedToolCall, leakedToolCallHint, MAX_LEAK_RETRIES } from '../shared/leaked-tool-call.js';
@@ -70,8 +71,7 @@ function workerTimeout(external, ms) {
 }
 export async function runWorker(input) {
     const tools = input.tools ?? DEFAULT_TOOLS;
-    const extensionArgs = (input.extensions ?? []).flatMap(e => ['-e', e]);
-    const baseArgs = [...extensionArgs, ...CHILD_BASE_ARGS, '--mode', 'json', '--tools', tools];
+    const baseArgs = [...childBaseArgs(input.extensions ?? []), '--mode', 'json', '--tools', tools];
     const timeoutMs = input.timeoutMs ?? RESEARCH_WORKER_TIMEOUT_MS;
     let hint = null;
     // Loop-kill and timeout share one restart budget, mirroring

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

@@ -4,13 +4,14 @@ import { openCache as defaultOpenCache } from './docs-cache.js';
 import { retrieveChunks as defaultRetrieveChunks } from './docs-retrieve.js';
 import { docsRaw, formatResultText, buildPrompt, buildVersionBanner } from './docs-core.js';
 import { formatNpmVersionSection } from './npm-version.js';
-import { runChild, CHILD_BASE_ARGS } from '../shared/child-process.js';
+import { runChild } from '../shared/child-process.js';
+import { childBaseArgs } from '../shared/child-extensions.js';
 import { parseChildOutput, isExcerptInContent } from '../shared/child-output.js';
 import { getPiInvocation } from '../shared/pi-invocation.js';
 import { formatChildFailure, makeWorkerTool } from './shared.js';
 import { normalizeQuery } from './research-cache.js';
 import { projectDocsRaw, buildProjectPrompt } from './docs-project.js';
-const CHILD_ARGS = [...CHILD_BASE_ARGS, '--no-tools'];
+const childArgs = () => [...childBaseArgs(), '--no-tools'];
 const RENDER_QUERY_MAX = 100;
 const Params = Type.Object({
     module: Type.String({
@@ -105,7 +106,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
                 };
                 const concatenated = chunks.map(c => c.content).join('\n\n');
                 const prompt = buildProjectPrompt(projectName, params.query, concatenated);
-                const invocation = getPiInvocation([...CHILD_ARGS], prompt);
+                const invocation = getPiInvocation(childArgs(), prompt);
                 const child = await runChild(spawn, invocation, ctx.cwd, signal);
                 const failure = formatChildFailure(child, 'Project docs lookup aborted.');
                 if (failure !== null) {
@@ -207,7 +208,7 @@ export function registerPiWorkerDocs(pi, internals = {}) {
             };
             const concatenated = chunks.map(c => c.content).join('\n\n');
             const prompt = buildPrompt(pkg, params.query, concatenated);
-            const invocation = getPiInvocation([...CHILD_ARGS], prompt);
+            const invocation = getPiInvocation(childArgs(), prompt);
             const child = await runChild(spawn, invocation, ctx.cwd, signal);
             const failure = formatChildFailure(child, 'Docs lookup aborted.');
             if (failure !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.18.12",
+    "version": "0.18.13",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",