@mjasnikovs/pi-task 0.17.8 → 0.17.10

package/dist/task/orchestrator.js

@@ -755,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/phases.js

@@ -655,7 +655,19 @@ export async function phaseCompose(deps, refined, research, qa) {
         // value starts at GOAL.
         const stripped = stripSpecPreamble(text);
         const problem = validateSpecShape(stripped);
-        return problem ? { ok: false, problem } : { ok: true, value: stripped };
+        if (problem)
+            return { ok: false, problem };
+        // validateSpecShape only checks the VERIFY *header* exists. The
+        // critique gate and the handoff gate both require a *runnable*
+        // fenced block (parseVerifyBlock). Enforce the same bar here so a
+        // draft ending in a bare `VERIFY:` retries with emphasis now,
+        // instead of passing compose and being rejected downstream — which
+        // otherwise leaves a persisted VERIFY-less spec that resume can't
+        // heal.
+        if (parseVerifyBlock(stripped) === null) {
+            return { ok: false, problem: 'VERIFY block has no runnable ```bash fenced commands' };
+        }
+        return { ok: true, value: stripped };
     }, problem => new Error(`compose_invalid: ${problem}`));
 }
 export async function phaseCritique(deps, spec, refined, qa) {
@@ -716,6 +728,15 @@ export async function critiqueWithFallback(d, p) {
         const msg = err instanceof Error ? err.message : String(err);
         if (msg !== 'no_verify_block')
             throw err;
+        // Fall back to the compose draft — but only if it actually carries a
+        // runnable VERIFY block. Critique reaches its rewrite path precisely
+        // when the compose draft lacked one (triage is skipped in that case),
+        // so returning that same draft would persist a VERIFY-less spec the
+        // handoff gate rejects and resume can't heal. Compose now enforces a
+        // parseable VERIFY, so this should hold; keep the guard so a regression
+        // fails the run cleanly instead of shipping a broken spec.
+        if (parseVerifyBlock(p.spec) === null)
+            throw err;
         p.ctx.ui.notify("Critique couldn't produce a VERIFY block — using compose draft. Edit the spec manually if needed.", 'warning');
         return p.spec;
     }

package/dist/task/task-io.js

@@ -66,7 +66,7 @@ export async function readTaskFile(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/package.json

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