@mjasnikovs/pi-task 0.17.7 → 0.17.9

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/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;
@@ -754,7 +755,7 @@ async function handleTaskResume(args, ctx) {
             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/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,11 +59,14 @@ 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`);
-    const body = raw.replace(/^---\n[\s\S]*?\n---\n?/, '');
+    const body = raw.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '');
     return { frontMatter: fm, body };
 }
 export async function writeTaskFile(cwd, fm, body) {

package/dist/task/task-parsers.js

@@ -32,11 +32,15 @@ export function emitFrontMatter(fm) {
     return lines.join('\n');
 }
 export function parseFrontMatter(content) {
-    const m = /^---\n([\s\S]*?)\n---\n?/.exec(content);
+    // `\r?\n` throughout so a CRLF/Windows task file parses too. Reads normally
+    // pass through readTextFile (which normalizes to LF), but tolerating CRLF at
+    // the parser itself is the safety net for any read site that forgets to —
+    // exactly the class of miss that shipped in 0.17.8. See shared/fs-text.ts.
+    const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
     if (!m)
         return null;
     const obj = {};
-    for (const line of m[1].split('\n')) {
+    for (const line of m[1].split(/\r?\n/)) {
         const kv = /^([a-z_]+):\s*(.*)$/.exec(line);
         if (kv)
             obj[kv[1]] = kv[2];
@@ -69,7 +73,9 @@ export function sectionRegex(heading) {
     // after a long /task-auto run). Keeping blanks in group 2 lets the `.trim()`
     // every reader already applies collapse them, which also self-heals files
     // that already accumulated the gap.
-    return new RegExp(`(^## ${escapeRegex(heading)}[ \\t]*\\n)([\\s\\S]*?)(?=^## |$(?![\\s\\S]))`, 'm');
+    // `[ \t]*\r?\n` on the heading line so a CRLF file still matches the section
+    // (belt-and-suspenders alongside read-boundary normalization; see fs-text.ts).
+    return new RegExp(`(^## ${escapeRegex(heading)}[ \\t]*\\r?\\n)([\\s\\S]*?)(?=^## |$(?![\\s\\S]))`, 'm');
 }
 export function extractSection(body, heading) {
     const m = sectionRegex(heading).exec(body);

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.7",
+    "version": "0.17.9",
     "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",