@mjasnikovs/pi-task 0.17.17 → 0.17.19

package/dist/task/auto-io.d.ts

@@ -7,6 +7,17 @@ export interface TaskEntry {
 export declare function allocateAutoId(cwd: string): Promise<string>;
 /** Parse a decompose-phase model output into a clean list of titles. */
 export declare function parseDecomposeList(raw: string): string[];
+/** Parsed DECOMPOSE_COVERAGE_PROMPT verdict. */
+export interface CoverageVerdict {
+    kind: 'complete' | 'incomplete';
+    missing: string[];
+}
+/**
+ * Parse the coverage-triage child's verdict. Returns null when no COVERAGE tag
+ * is present (the model wrote prose) — the caller treats that as "accept the
+ * list as-is", so a malformed judgment can never block planning.
+ */
+export declare function parseCoverageVerdict(raw: string): CoverageVerdict | null;
 /** Parse the "## tasks" checkbox list. */
 export declare function parseTaskList(body: string): TaskEntry[];
 /** Build the initial AUTO-file body. */

package/dist/task/auto-io.js

@@ -39,6 +39,29 @@ export function parseDecomposeList(raw) {
     }
     return out;
 }
+/**
+ * Parse the coverage-triage child's verdict. Returns null when no COVERAGE tag
+ * is present (the model wrote prose) — the caller treats that as "accept the
+ * list as-is", so a malformed judgment can never block planning.
+ */
+export function parseCoverageVerdict(raw) {
+    const tag = /^\s*COVERAGE:\s*(COMPLETE|INCOMPLETE)\s*$/im.exec(raw);
+    if (!tag)
+        return null;
+    if (tag[1].toUpperCase() === 'COMPLETE')
+        return { kind: 'complete', missing: [] };
+    const missing = [];
+    for (const line of raw.split('\n')) {
+        const m = /^\s*MISSING:\s*(.+?)\s*$/i.exec(line);
+        if (m && m[1].length > 0)
+            missing.push(m[1]);
+        if (missing.length >= 8)
+            break;
+    }
+    // INCOMPLETE with no MISSING lines carries no actionable signal to reprompt
+    // with — treat it like an unparseable verdict rather than looping blind.
+    return missing.length === 0 ? null : { kind: 'incomplete', missing };
+}
 const CHECKBOX_RE = /^- \[([ xX])\]\s+(.+?)\s*$/;
 const PRODUCED_ID_RE = /^(TASK_\d{4,})\s{2,}(.+)$/;
 /** Parse the "## tasks" checkbox list. */

package/dist/task/auto-orchestrator.js

@@ -10,10 +10,10 @@ import * as path from 'node:path';
 import { gateRunTask } from './orchestrator.js';
 import { parseClarifyList, parseAutoAnswer, autoAnswerHasTag, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
-import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT } from './auto-prompts.js';
+import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT, DECOMPOSE_COVERAGE_PROMPT } from './auto-prompts.js';
 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 { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, 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';
@@ -29,6 +29,18 @@ import { runGatesForTask } from './task-gates.js';
 // when the model emits NONE), but a model that never says NONE would otherwise
 // barrage the user — the real mx5 run asked 10, several of them redundant.
 const MAX_CLARIFY_QUESTIONS = 8;
+// Bounded coverage-triage rounds after decompose: judge → reprompt-with-missing
+// → judge again, at most. Two rounds so one flaky retry doesn't end the gate,
+// while a judge that keeps flagging can't loop the plan phase forever.
+const MAX_COVERAGE_ROUNDS = 2;
+/** Reprompt prefix when the coverage triage found feature areas no task covers. */
+function coverageRepromptHint(missing) {
+    return ('[SYSTEM NOTE: Your previous task list was INCOMPLETE — no task covered: '
+        + missing.join('; ')
+        + '. Regenerate the FULL ordered checkbox list for the ENTIRE feature: every '
+        + 'task your previous list already had (reworded freely) PLUS tasks covering '
+        + 'the areas above. Output every task, one "- [ ] " line each, nothing else.]');
+}
 // Matches pi's @-file completion token (a path after @, until whitespace).
 const MENTION_RE = /(?:^|\s)@([^\s]+)/g;
 // Trailing punctuation a user naturally types AFTER an @-mention when it sits in
@@ -391,12 +403,43 @@ export async function planAuto(ctx, cwd, feature, deps) {
     }
     const clarifications = answers.join('\n');
     // decompose
-    const listRaw = await deps.runChild('auto-decompose', 'read', AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications));
+    const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications);
+    const listRaw = await deps.runChild('auto-decompose', 'read', decomposePrompt);
+    let planTitles = parseDecomposeList(listRaw);
+    logPlanDebug(cwd, `decompose produced ${planTitles.length} title(s)`);
+    // Coverage gate: a stochastic degenerate completion (live mx5: ONE task +
+    // natural EOS for an 18KB design doc) is nonempty, so the length guard below
+    // never fires and the whole run "completes" after one task. Judge the list
+    // against the feature with a no-tools child; on INCOMPLETE, re-run decompose
+    // with the missing areas as a hint. Longest-list-wins so a flaky retry can
+    // never replace a better list; best-effort so a triage fault never blocks
+    // planning (mirrors triageClarifyQuestion).
+    for (let round = 0; round < MAX_COVERAGE_ROUNDS && planTitles.length > 0; round++) {
+        let verdict;
+        try {
+            verdict = parseCoverageVerdict(await deps.runChild('decompose-coverage', '', DECOMPOSE_COVERAGE_PROMPT(featureForModel, clarifications, planTitles)));
+        }
+        catch {
+            break;
+        }
+        if (verdict === null || verdict.kind === 'complete') {
+            logPlanDebug(cwd, `decompose-coverage round ${round + 1}: `
+                + (verdict === null ? 'no verdict — accepting list' : 'COMPLETE'));
+            break;
+        }
+        logPlanDebug(cwd, `decompose-coverage round ${round + 1}: INCOMPLETE — missing: `
+            + verdict.missing.join('; ').slice(0, 300));
+        const retryRaw = await deps.runChild('auto-decompose', 'read', prependHint(coverageRepromptHint(verdict.missing), decomposePrompt));
+        const retryTitles = parseDecomposeList(retryRaw);
+        logPlanDebug(cwd, `decompose retry produced ${retryTitles.length} title(s)`);
+        if (retryTitles.length > planTitles.length)
+            planTitles = retryTitles;
+    }
     // Thread the feature's spec doc(s) into every title so each per-task
     // pipeline — which only ever sees its title — reads the real spec instead of
     // a lossy one-line paraphrase of it.
     const refs = await readableMentions(cwd, feature);
-    const titles = attachSpecRefs(parseDecomposeList(listRaw), refs);
+    const titles = attachSpecRefs(planTitles, refs);
     if (titles.length === 0) {
         announceDone(ctx, '/task-auto: no tasks produced from the feature.', 'warning');
         return null;
@@ -418,7 +461,8 @@ export async function planAuto(ctx, cwd, feature, deps) {
 /** The two feature-level planning children, shown as steps in the loader. */
 const AUTO_PLAN_STEPS = {
     'auto-clarify': { step: 'clarify', stepNum: 1 },
-    'auto-decompose': { step: 'decompose', stepNum: 2 }
+    'auto-decompose': { step: 'decompose', stepNum: 2 },
+    'decompose-coverage': { step: 'coverage', stepNum: 2 }
 };
 const AUTO_PLAN_STEP_TOTAL = 2;
 function defaultDeps(ctx, cwd, signal, title) {

package/dist/task/auto-prompts.d.ts

@@ -14,3 +14,13 @@ export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string) =>
  * Decompose: output a markdown checkbox list of task titles (one line each).
  */
 export declare const AUTO_DECOMPOSE_PROMPT: (feature: string, clarifications: string) => string;
+/**
+ * Coverage triage: judge whether a decomposed task list covers the whole
+ * feature. Guards the plan — the highest-leverage artifact in /task-auto —
+ * against a degenerate-but-nonempty decompose completion (live mx5: the model
+ * emitted ONE task for an 18KB design doc with a natural EOS, and the only
+ * existing gate was `titles.length === 0`, so the run "completed" after one
+ * task). Pure judgment over text already in hand, so it runs with --no-tools.
+ * Output MUST match parseCoverageVerdict.
+ */
+export declare const DECOMPOSE_COVERAGE_PROMPT: (feature: string, clarifications: string, list: string[]) => string;

package/dist/task/auto-prompts.js

@@ -89,3 +89,37 @@ RULES:
   doc; phrase them as imperative directives (e.g. "use Bun's built-in bundler, do
   not add vite"). Do NOT invent decisions — only restate ones from CLARIFICATIONS.
 - Output the checkbox list and NOTHING else (no preamble, no numbering).`;
+/**
+ * Coverage triage: judge whether a decomposed task list covers the whole
+ * feature. Guards the plan — the highest-leverage artifact in /task-auto —
+ * against a degenerate-but-nonempty decompose completion (live mx5: the model
+ * emitted ONE task for an 18KB design doc with a natural EOS, and the only
+ * existing gate was `titles.length === 0`, so the run "completed" after one
+ * task). Pure judgment over text already in hand, so it runs with --no-tools.
+ * Output MUST match parseCoverageVerdict.
+ */
+export const DECOMPOSE_COVERAGE_PROMPT = (feature, clarifications, list) => `You are auditing a task decomposition for completeness. Below is a FEATURE
+REQUEST (with any referenced design spec inlined), the CLARIFICATIONS the user
+settled, and the proposed ordered TASK LIST that is supposed to implement ALL
+of it. Each listed task will later get its own research and spec — so judge
+coverage only, not wording or level of detail.
+
+FEATURE REQUEST:
+${feature.trim()}
+
+CLARIFICATIONS:
+${clarifications.trim() || '(none)'}
+
+TASK LIST:
+${list.map((t, i) => `${i + 1}. ${t}`).join('\n')}
+
+Judge ONE thing: taken together, do these tasks cover the whole feature end to
+end? An area is MISSING only when NO task plausibly covers it — do not flag
+wording, ordering, task size, or detail a task's own research will fill in.
+
+Output — no preamble, no markdown:
+COVERAGE: COMPLETE
+or
+COVERAGE: INCOMPLETE
+MISSING: <feature area no task covers>
+(one MISSING line per uncovered area, most important first, at most 8)`;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.17",
-    "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
+    "version": "0.17.19",
+    "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",
     "types": "./dist/index.d.ts",
@@ -52,12 +52,30 @@
         "pi-package",
         "pi",
         "pi-extension",
+        "pi-coding-agent",
+        "pi.dev",
         "coding-agent",
+        "ai-agent",
+        "agent",
+        "subagent",
         "task-orchestration",
+        "spec-orchestration",
+        "spec-driven",
+        "task-planning",
+        "planning",
+        "autonomous",
         "local-llm",
+        "llm",
+        "llama-server",
         "remote",
-        "web"
+        "web-view",
+        "web-push"
     ],
+    "author": "mjasnikovs <mjasnikovs@googlemail.com>",
+    "homepage": "https://github.com/mjasnikovs/pi-task#readme",
+    "bugs": {
+        "url": "https://github.com/mjasnikovs/pi-task/issues"
+    },
     "repository": {
         "type": "git",
         "url": "git+https://github.com/mjasnikovs/pi-task.git"