@mjasnikovs/pi-task 0.17.6 → 0.17.8

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

@@ -3,7 +3,14 @@ import type { EventEmitter } from 'node:events';
 export declare const KILL_GRACE_MS = 5000;
 /** Base flags shared by all child pi invocations. */
 export declare const CHILD_BASE_ARGS: readonly ["--print", "--no-skills", "--no-extensions", "--no-prompt-templates", "--no-context-files", "--no-session"];
+/** The subset of a child's stdin we use: write the prompt, then close it. */
+export interface WritableLike {
+    write(chunk: string): boolean;
+    end(): void;
+}
 export interface ProcLike extends EventEmitter {
+    /** Present only when the child was spawned with stdin 'pipe' (prompt delivery). */
+    stdin: WritableLike | null;
     stdout: EventEmitter | null;
     stderr: EventEmitter | null;
     killed: boolean;
@@ -12,7 +19,7 @@ export interface ProcLike extends EventEmitter {
 export type SpawnFn = (command: string, args: ReadonlyArray<string>, options: {
     cwd: string;
     shell: boolean;
-    stdio: ['ignore', 'pipe', 'pipe'];
+    stdio: ['ignore' | 'pipe', 'pipe', 'pipe'];
 }) => ProcLike;
 export interface ChildResult {
     stdout: string;
@@ -105,6 +112,7 @@ export declare class JsonEventSink {
 export declare function runChild(spawn: SpawnFn, invocation: {
     command: string;
     args: ReadonlyArray<string>;
+    stdin?: string;
 }, cwd: string, signal: AbortSignal | undefined, opts?: RunChildOptions): Promise<ChildResult>;
 export declare function runChildDefault(invocation: {
     command: string;

package/dist/shared/child-process.js

@@ -169,11 +169,22 @@ export function runChild(spawn, invocation, cwd, signal, opts) {
         let stderr = '';
         let aborted = false;
         const discardStdout = opts?.mode === 'text' && opts.discardStdout === true;
+        // Deliver the prompt on stdin, not argv: a large prompt (e.g. an inlined
+        // design doc) blows past the OS command-line limit — Windows CreateProcessW
+        // caps it at 32767 chars and Node throws `spawn ENAMETOOLONG`. When a
+        // prompt is present we open stdin as a pipe; otherwise keep it 'ignore'
+        // (git and other arg-only spawns are unaffected). See GitHub issue #1.
+        const usesStdin = invocation.stdin !== undefined;
         const proc = spawn(invocation.command, invocation.args, {
             cwd,
             shell: false,
-            stdio: ['ignore', 'pipe', 'pipe']
+            stdio: [usesStdin ? 'pipe' : 'ignore', 'pipe', 'pipe']
         });
+        if (usesStdin) {
+            // pi reads the prompt from stdin and waits for EOF, so write then end.
+            proc.stdin?.write(invocation.stdin);
+            proc.stdin?.end();
+        }
         // One kill path, shared by user-abort and loop-kill: SIGTERM, then
         // SIGKILL after a grace period if the child ignored the term.
         const killProc = () => {

package/dist/shared/fs-text.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Text-file reads with line endings normalized to LF.
+ *
+ * Every task-file parser in pi-task assumes `\n` line endings: the front-matter
+ * regex (`^---\n`), the body-delimiter strip, `sectionRegex` (`## h[ \t]*\n`),
+ * the checkbox/VERIFY-token line splits. On Windows a task file can carry CRLF
+ * (an editor save, or a `git` checkout with `core.autocrlf=true`), and classic
+ * Mac tooling can emit lone CR. Any of those makes `parseFrontMatter` return
+ * null ("malformed front matter") and every `extractSection` miss.
+ *
+ * Rather than teach each parser about `\r`, we normalize ONCE at the read
+ * boundary — the single place file bytes enter the task layer — so everything
+ * downstream sees LF. See GitHub issue #1.
+ */
+/** Collapse CRLF and lone CR to LF. `\r\n?` matches Windows CRLF and classic-Mac CR. */
+export declare function normalizeNewlines(text: string): string;
+/** Read a UTF-8 text file with line endings normalized to LF. */
+export declare function readTextFile(filePath: string): Promise<string>;

package/dist/shared/fs-text.js

@@ -0,0 +1,23 @@
+/**
+ * Text-file reads with line endings normalized to LF.
+ *
+ * Every task-file parser in pi-task assumes `\n` line endings: the front-matter
+ * regex (`^---\n`), the body-delimiter strip, `sectionRegex` (`## h[ \t]*\n`),
+ * the checkbox/VERIFY-token line splits. On Windows a task file can carry CRLF
+ * (an editor save, or a `git` checkout with `core.autocrlf=true`), and classic
+ * Mac tooling can emit lone CR. Any of those makes `parseFrontMatter` return
+ * null ("malformed front matter") and every `extractSection` miss.
+ *
+ * Rather than teach each parser about `\r`, we normalize ONCE at the read
+ * boundary — the single place file bytes enter the task layer — so everything
+ * downstream sees LF. See GitHub issue #1.
+ */
+import * as fsp from 'node:fs/promises';
+/** Collapse CRLF and lone CR to LF. `\r\n?` matches Windows CRLF and classic-Mac CR. */
+export function normalizeNewlines(text) {
+    return text.replace(/\r\n?/g, '\n');
+}
+/** Read a UTF-8 text file with line endings normalized to LF. */
+export async function readTextFile(filePath) {
+    return normalizeNewlines(await fsp.readFile(filePath, 'utf8'));
+}

package/dist/shared/pi-invocation.d.ts

@@ -1,7 +1,13 @@
 /** Pick the right way to re-invoke pi: prefer the current pi script under the
  *  current node/bun runtime; fall back to the `pi` shim on PATH. Mirrors the
- *  pattern from pi-coding-agent's official subagent example. */
-export declare function getPiInvocation(args: string[]): {
+ *  pattern from pi-coding-agent's official subagent example.
+ *
+ *  `stdin`, when given, is the prompt to feed the child over stdin instead of as
+ *  an argv element — pi reads its prompt from stdin when no positional message
+ *  is passed, which keeps a large prompt off the length-limited command line
+ *  (see runChild / GitHub issue #1). It is threaded through unchanged. */
+export declare function getPiInvocation(args: string[], stdin?: string): {
     command: string;
     args: string[];
+    stdin?: string;
 };

package/dist/shared/pi-invocation.js

@@ -2,23 +2,28 @@ import * as fs from 'node:fs';
 import * as path from 'node:path';
 /** Pick the right way to re-invoke pi: prefer the current pi script under the
  *  current node/bun runtime; fall back to the `pi` shim on PATH. Mirrors the
- *  pattern from pi-coding-agent's official subagent example. */
-export function getPiInvocation(args) {
+ *  pattern from pi-coding-agent's official subagent example.
+ *
+ *  `stdin`, when given, is the prompt to feed the child over stdin instead of as
+ *  an argv element — pi reads its prompt from stdin when no positional message
+ *  is passed, which keeps a large prompt off the length-limited command line
+ *  (see runChild / GitHub issue #1). It is threaded through unchanged. */
+export function getPiInvocation(args, stdin) {
     // Test/dev override: point at a specific pi binary directly. Bypasses the
     // re-invoke-current-script heuristic, which goes wrong under `bun test`
     // (currentScript is the .test.ts file, not a pi entrypoint).
     if (process.env.PI_BIN) {
-        return { command: process.env.PI_BIN, args };
+        return { command: process.env.PI_BIN, args, stdin };
     }
     const currentScript = process.argv[1];
     const isBunVirtualScript = currentScript?.startsWith('/$bunfs/root/');
     if (currentScript && !isBunVirtualScript && fs.existsSync(currentScript)) {
-        return { command: process.execPath, args: [currentScript, ...args] };
+        return { command: process.execPath, args: [currentScript, ...args], stdin };
     }
     const execName = path.basename(process.execPath).toLowerCase();
     const isGenericRuntime = /^(node|bun)(\.exe)?$/.test(execName);
     if (!isGenericRuntime) {
-        return { command: process.execPath, args };
+        return { command: process.execPath, args, stdin };
     }
-    return { command: 'pi', args };
+    return { command: 'pi', args, stdin };
 }

package/dist/task/auto-io.js

@@ -9,6 +9,7 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { tasksDir, ensureTasksDir, readTaskFile, setTaskSection } from './task-io.js';
 import { extractSection, parseFrontMatter } from './task-parsers.js';
+import { readTextFile } from '../shared/fs-text.js';
 import { RESUMABLE_STATES } from './task-types.js';
 const AUTO_FILE_RE = /^(TASK_AUTO_\d{4,})\.md$/;
 const MAX_TASKS = 30;
@@ -117,7 +118,7 @@ export async function findResumableAuto(cwd) {
         if (!m)
             continue;
         try {
-            const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+            const raw = await readTextFile(path.join(tasksDir(cwd), f));
             const fm = parseFrontMatter(raw);
             if (!fm)
                 continue;

package/dist/task/auto-orchestrator.js

@@ -15,6 +15,7 @@ import { GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT } from './prompts.js';
 import { isDuplicateQuestion, MAX_DUP_STRIKES, DUP_REPROMPT_HINT } from './question-dedup.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
 import { writeTaskFile, readTaskFile, updateTaskFrontMatter, taskFilePath, tasksDir } from './task-io.js';
+import { readTextFile } from '../shared/fs-text.js';
 import { findPhantomImports, rewritePhantomSpecifiers } from '../workers/phantom-imports.js';
 import { runPhaseChild, prependHint, USER_CANCELLED } from './child-runner.js';
 import { refineExistingFilesBlock } from './phases.js';
@@ -134,7 +135,9 @@ export async function expandFeatureMentions(cwd, feature) {
             continue;
         seen.add(rel);
         try {
-            const body = await fsp.readFile(path.resolve(cwd, rel), 'utf8');
+            // Normalize CRLF/CR so an @-mentioned design doc saved on Windows
+            // inlines with LF endings the downstream phase parsers expect.
+            const body = await readTextFile(path.resolve(cwd, rel));
             if (body.trim().length > 0) {
                 blocks.push(`--- contents of ${rel} ---\n${body.trim()}`);
             }

package/dist/task/child-runner.d.ts

@@ -23,7 +23,7 @@ export interface PhaseRunResult {
     /** Set when the child's final turn failed with stopReason "error" (model/provider failure). */
     modelError?: string;
 }
-export declare function childArgs(tools: string, prompt: string): string[];
+export declare function childArgs(tools: string): string[];
 export declare const USER_CANCELLED = "__user_cancelled__";
 /**
  * Run a child pi process with JSON event-stream output, loop detection, and

package/dist/task/child-runner.js

@@ -44,7 +44,7 @@ export function connectionRetryBackoffMs(attempt) {
 }
 const defaultSleep = (ms) => new Promise(resolve => setTimeout(resolve, ms));
 // ─── Spawn helpers ───────────────────────────────────────────────────────────
-export function childArgs(tools, prompt) {
+export function childArgs(tools) {
     // `--mode json` puts the child into the structured event stream the
     // unified runner parses in `mode: 'json-events'`. Without it the child
     // emits plain text, every line fails JSON.parse, finalText stays empty,
@@ -55,8 +55,12 @@ export function childArgs(tools, prompt) {
     // instead of `--tools ''` (which pi would reject). Used by pure-judgment
     // phases like critique-triage that should reason only over the text we
     // hand them, never spend time reading the repo.
+    //
+    // The prompt is NOT an argv element: it goes to the child over stdin (see
+    // 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, prompt];
+    return [...CHILD_BASE_ARGS, '--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.
@@ -68,7 +72,7 @@ export const USER_CANCELLED = '__user_cancelled__';
  * phase-level code.
  */
 export async function runChild(cwd, tools, prompt, signal, onLine, onContextUsage, onToolCall, spawnFn) {
-    const invocation = getPiInvocation(childArgs(tools, prompt));
+    const invocation = getPiInvocation(childArgs(tools), prompt);
     let loopHit;
     const result = await runChildUnified(spawnFn ?? spawn, invocation, cwd, signal, {
         mode: 'json-events',

package/dist/task/enrichment.d.ts

@@ -3,7 +3,14 @@
  * orchestrator can fan out docs/URL lookups before the research phase.
  */
 export declare function extractEnrichTargets(text: string): {
+    /** Packages that get a (heavy) docs fetch — capped at ENRICH_CAP. */
     packages: string[];
+    /**
+     * Every named package, up to ENRICH_VERSION_CAP, for a cheap live npm version
+     * lookup. A superset of `packages`; the extras get a version block only (no
+     * docs body). Order-preserving and deduped, same as `packages`.
+     */
+    versionPackages: string[];
     urls: string[];
     services: Array<{
         name: string;

package/dist/task/enrichment.js

@@ -21,6 +21,13 @@ const ENRICH_DENYLIST = new Set([
     'rm'
 ]);
 const ENRICH_CAP = 3;
+// Heavy docs/url fetches stay capped at ENRICH_CAP (each is a worker spawn +
+// page fetch). A live npm VERSION lookup is just one cheap registry GET, so it
+// can cover far more packages — every dependency a task explicitly names should
+// get a grounded latest-version block, not just the first ENRICH_CAP of them. A
+// task that named 6 runtime deps used to leave the 4th–6th (e.g. tailwindcss)
+// with NO live version, so a version question fell back to stale training data.
+const ENRICH_VERSION_CAP = 12;
 const ENRICH_SERVICE_HEADER = 'EXTERNAL-DEPENDENCIES';
 const ENRICH_HEADER_LINE_RE = /^[A-Z][A-Z0-9 -]+$/;
 const ENRICH_SERVICE_BULLET_RE = /^\s*-\s+(.+?)\s{2,}(.+?)\s*$/;
@@ -61,13 +68,15 @@ function parseServices(text) {
     return out;
 }
 export function extractEnrichTargets(text) {
-    const pkgs = new Set();
+    const pkgs = [];
+    const seen = new Set();
     for (const m of text.matchAll(ENRICH_PKG_RE)) {
         const t = m[1];
-        if (ENRICH_DENYLIST.has(t))
+        if (ENRICH_DENYLIST.has(t) || seen.has(t))
             continue;
-        pkgs.add(t);
-        if (pkgs.size >= ENRICH_CAP)
+        seen.add(t);
+        pkgs.push(t);
+        if (pkgs.length >= ENRICH_VERSION_CAP)
             break;
     }
     const urls = new Set();
@@ -78,5 +87,5 @@ export function extractEnrichTargets(text) {
             break;
     }
     const services = parseServices(text);
-    return { packages: [...pkgs], urls: [...urls], services };
+    return { packages: pkgs.slice(0, ENRICH_CAP), versionPackages: pkgs, urls: [...urls], services };
 }

package/dist/task/external-context.d.ts

@@ -10,6 +10,7 @@
  */
 import { docsRaw } from '../workers/docs-core.js';
 import { fetchRaw } from '../workers/fetch-core.js';
+import { npmVersionLookup } from '../workers/npm-version.js';
 import type { SearchCoreInput, SearchCoreResult } from '../workers/search-core.js';
 import type { PhaseDeps } from './child-runner.js';
 /** Injectable workers so enrichment is testable without spawning real lookups. */
@@ -17,6 +18,7 @@ export interface ExternalContextDeps {
     docsRaw?: typeof docsRaw;
     fetchRaw?: typeof fetchRaw;
     searchFn?: (input: SearchCoreInput) => Promise<SearchCoreResult>;
+    npmVersionLookup?: typeof npmVersionLookup;
 }
 type GatherDeps = Pick<PhaseDeps, 'cwd' | 'signal' | 'recordSubStep'>;
 /**

package/dist/task/external-context.js

@@ -10,7 +10,7 @@
  */
 import { docsRaw } from '../workers/docs-core.js';
 import { fetchRaw } from '../workers/fetch-core.js';
-import { formatNpmVersionSection } from '../workers/npm-version.js';
+import { formatNpmVersionSection, npmVersionLookup } from '../workers/npm-version.js';
 import { search as defaultSearch } from '../workers/search-core.js';
 import { extractEnrichTargets } from './enrichment.js';
 import { formatServiceBlock, formatFreshnessSkippedBlock } from './service-blocks.js';
@@ -22,7 +22,15 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
     const docsRawFn = researchDeps.docsRaw ?? docsRaw;
     const fetchRawFn = researchDeps.fetchRaw ?? fetchRaw;
     const searchFn = researchDeps.searchFn ?? defaultSearch;
+    const npmVersionFn = researchDeps.npmVersionLookup ?? npmVersionLookup;
     const enrichTargets = extractEnrichTargets(refined);
+    // Every named dep past the heavy-docs cap still gets a cheap live version
+    // lookup, so a version block exists for ALL of them (the docs-fetched ones
+    // emit their version below from the bundled lookup). Without this, deps 4..N
+    // had no live version and a "which version?" question fell back to the model's
+    // stale training data — how tailwindcss got pinned to an old major.
+    const docsPkgs = new Set(enrichTargets.packages);
+    const extraVersionPkgs = enrichTargets.versionPackages.filter(p => !docsPkgs.has(p));
     if (enrichTargets.packages.length === 0
         && enrichTargets.urls.length === 0
         && enrichTargets.services.length === 0) {
@@ -30,7 +38,7 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
     }
     const enrichSections = [];
     const tEnrichStart = Date.now();
-    const [docsResults, fetchResults, serviceResults] = await Promise.all([
+    const [docsResults, fetchResults, serviceResults, extraVersionResults] = await Promise.all([
         Promise.all(enrichTargets.packages.map(pkg => docsRawFn({
             pkg,
             query: refined.split('\n').find(l => l.trim()) ?? refined,
@@ -42,16 +50,22 @@ export async function gatherExternalContext(refined, deps, researchDeps = {}) {
             query: `${s.name} ${s.query}`,
             count: 3,
             signal: deps.signal
-        }).catch(() => null)))
+        }).catch(() => null))),
+        Promise.all(extraVersionPkgs.map(pkg => npmVersionFn(pkg, { signal: deps.signal }).catch(() => null)))
     ]);
-    // npm version blocks come from docsRaw's bundled lookup and lead the
-    // section so the model anchors on live version data before reading
-    // the docs body.
+    // npm version blocks lead the section so the model anchors on live version
+    // data before reading any docs body. The docs-fetched packages carry their
+    // version in docsRaw's bundled lookup; the remaining named deps get theirs
+    // from the cheap standalone lookup above. Together they cover EVERY named dep.
     for (let i = 0; i < enrichTargets.packages.length; i++) {
         const v = docsResults[i]?.npmVersion;
         if (v)
             enrichSections.push(formatNpmVersionSection(v));
     }
+    for (const v of extraVersionResults) {
+        if (v)
+            enrichSections.push(formatNpmVersionSection(v));
+    }
     for (let i = 0; i < enrichTargets.packages.length; i++) {
         const r = docsResults[i];
         if (r?.kind === 'ok' && r.chunks.length > 0) {

package/dist/task/orchestrator.js

@@ -21,6 +21,7 @@ import { PHASES, postCommitPhase } from './phases.js';
 import { handleFailure } from './failure-classifier.js';
 import { PHASE_INDEX, PHASE_ORDER, RESUMABLE_STATES } from './task-types.js';
 import { normaliseTaskId, parseFrontMatter, extractSection } from './task-parsers.js';
+import { readTextFile } from '../shared/fs-text.js';
 import { allocateTaskId, ensureTasksDir, readSection, readTaskFile, setTaskSection, taskFilePath, tasksDir, updateTaskFrontMatter, writeTaskFile } from './task-io.js';
 import { startWidget } from './widget.js';
 import { armImplWidget, disarmImplWidget, setupImplWidget } from './impl-widget.js';
@@ -705,7 +706,7 @@ async function handleTaskList(_args, ctx) {
     const rows = [];
     for (const f of taskFiles) {
         try {
-            const raw = await fsp.readFile(path.join(tasksDir(cwd), f), 'utf8');
+            const raw = await readTextFile(path.join(tasksDir(cwd), f));
             const fm = parseFrontMatter(raw);
             if (!fm)
                 continue;

package/dist/task/prompts.js

@@ -221,6 +221,7 @@ LIVE-DATA RULE:
 - "### service: <name>" blocks are LIVE web data; authoritative over training data for that service.
 - "### freshness-check skipped" → tag UNKNOWN and say current state needs verification.
 - No npm block + question is about latest/current version → tag UNKNOWN (training data goes stale).
+- VERSION-PIN questions ("pin to X.y vs latest", "which major version") are costly-to-reverse build-shaping choices: unless the spec or an "### npm:" block already settles it (then ANSWER that value), tag UNKNOWN and surface it. NEVER auto-answer a downgrade to an OLDER major "to avoid breaking changes" from memory — that reasoning is exactly the stale-training-data trap. If an "### npm:" block shows a newer major than your instinct, that block is the live latest; do not silently pin an older major the live data and spec never asked for.
 
 TRIAGE — run these checks IN ORDER first. The REVERSIBILITY TEST below applies ONLY to a question that survives all checks as a genuine preference.
 

package/dist/task/task-io.js

@@ -8,6 +8,7 @@ import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
 import { TASKS_DIR_NAME } from './task-types.js';
 import { emitFrontMatter, parseFrontMatter, sectionRegex } from './task-parsers.js';
+import { readTextFile } from '../shared/fs-text.js';
 // ─── Directory & path helpers ────────────────────────────────────────────────
 export function tasksDir(cwd) {
     return path.join(cwd, TASKS_DIR_NAME);
@@ -58,7 +59,10 @@ export async function allocateTaskId(cwd) {
 }
 // ─── File read/write ─────────────────────────────────────────────────────────
 export async function readTaskFile(cwd, id) {
-    const raw = await fsp.readFile(taskFilePath(cwd, id), 'utf8');
+    // Normalize CRLF/CR → LF at the read boundary: every parser below (front
+    // matter, body strip, sectionRegex) assumes '\n'. A Windows/autocrlf file
+    // would otherwise fail as "malformed front matter". See shared/fs-text.ts.
+    const raw = await readTextFile(taskFilePath(cwd, id));
     const fm = parseFrontMatter(raw);
     if (!fm)
         throw new Error(`malformed front matter in ${id}.md`);

package/dist/workers/docs-core.js

@@ -423,7 +423,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([...CHILD_ARGS], 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

@@ -24,7 +24,7 @@ export async function fetchFocused(input) {
         title: cleaned.title,
         content: truncated
     });
-    const invocation = getPiInvocation([...CHILD_ARGS, prompt]);
+    const invocation = getPiInvocation([...CHILD_ARGS], prompt);
     const childResult = await runChild(spawnFn, invocation, input.cwd, input.signal);
     if (childResult.aborted) {
         return {

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

@@ -72,7 +72,7 @@ export async function runWorker(input) {
     let leakRetries = 0;
     for (;;) {
         const prompt = hint === null ? input.prompt : `${hint}\n\n${input.prompt}`;
-        const invocation = getPiInvocation([...baseArgs, prompt]);
+        const invocation = getPiInvocation([...baseArgs], prompt);
         const tStart = Date.now();
         let tFirstByte = null;
         // loop === false turns the guard off entirely (detector is null and no

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

@@ -104,7 +104,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([...CHILD_ARGS], prompt);
                 const child = await runChild(spawn, invocation, ctx.cwd, signal);
                 const failure = formatChildFailure(child, 'Project docs lookup aborted.');
                 if (failure !== null) {
@@ -206,7 +206,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([...CHILD_ARGS], 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.17.6",
+    "version": "0.17.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",