@mjasnikovs/pi-task 0.17.19 → 0.17.20

package/dist/task/auto-orchestrator.js

@@ -411,29 +411,55 @@ export async function planAuto(ctx, cwd, feature, deps) {
     // 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
+    // with the missing areas as a hint. Best-effort so a triage fault never blocks
     // planning (mirrors triageClarifyQuestion).
+    //
+    // A retry is adopted whenever it is NON-DEGENERATE — not only when it is
+    // strictly longer. The retry was generated WITH the judge's missing areas in
+    // its prompt, so it is the better-informed list, and the NEXT round's judge
+    // (not raw length) decides whether the gaps actually closed. Length survives
+    // only as a collapse floor against the one-task flake this gate exists for.
+    // mx5 run 5 (live): the hinted retry ADDED the flagged test-suite task but came
+    // back 29 titles vs the original 30 — strictly-longer discarded it, round 2
+    // re-judged the same unchanged list, and the known-incomplete plan shipped
+    // with no warning.
+    let unresolvedMissing = null;
     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 {
+            // Judge fault: unknown coverage, not known-missing — stay silent.
+            unresolvedMissing = null;
             break;
         }
         if (verdict === null || verdict.kind === 'complete') {
+            unresolvedMissing = null;
             logPlanDebug(cwd, `decompose-coverage round ${round + 1}: `
                 + (verdict === null ? 'no verdict — accepting list' : 'COMPLETE'));
             break;
         }
+        unresolvedMissing = verdict.missing;
         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)
+        if (retryTitles.length > 0 && retryTitles.length * 2 >= planTitles.length) {
             planTitles = retryTitles;
+        }
+        else {
+            logPlanDebug(cwd, `decompose retry discarded as degenerate (${retryTitles.length} vs ${planTitles.length} titles)`);
+        }
+    }
+    // Rounds exhausted with the last judgment still INCOMPLETE: the plan ships (the
+    // gate is best-effort), but silently shipping a KNOWN-gapped plan is how mx5
+    // run 5 lost its whole test suite — tell the user what the judge last flagged.
+    if (unresolvedMissing !== null) {
+        logPlanDebug(cwd, `decompose-coverage exhausted ${MAX_COVERAGE_ROUNDS} round(s) still INCOMPLETE — missing: `
+            + unresolvedMissing.join('; ').slice(0, 300));
+        ctx.ui.notify(`/task-auto: plan may be missing coverage — ${unresolvedMissing.join('; ').slice(0, 200)} — review the plan before running.`, 'warning');
     }
     // 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

package/dist/task/task-gates.js

@@ -212,7 +212,20 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 active.ui.notify(`${p.tag}: guideline edits on "${p.title}" failed repo health (${h.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
             }
         }
-        if (mode === 'edit' && !enforceEditsBlocked) {
+        if (mode === 'edit' && !enforceEditsBlocked && editsMade === false) {
+            // KNOWN-clean tree (dirty dep ran and found no code edits): skip the
+            // enforce commit AND the differential re-verify outright. Without this
+            // gate the commit is never empty — the .pi-tasks gate-trail lines written
+            // above make it real — so mx5 run 5 burned a full model re-verify on an
+            // UNCHANGED tree for all ~29 tasks, and the 10 FAILs those re-verifies
+            // produced (all real, pre-existing defects) were "reverted" into the
+            // void: the revert dropped a bookkeeping-only commit and the defect
+            // reports were discarded while the tasks stayed PASS. No edits ⇒ nothing
+            // to guard ⇒ no commit, no re-verify, no revert. The trail lines ride
+            // along in the next ordinary commit.
+            await rec('enforce(edit): no code edits — enforce commit and re-verify skipped');
+        }
+        else if (mode === 'edit' && !enforceEditsBlocked) {
             // Commit whatever the pass fixed as its own snapshot. A no-op when it made
             // no edits (nothing to commit) — then there is nothing to re-verify/revert.
             const enforceCommit = await deps.commit(p.cwd, `ENFORCE GUIDELINES: ${p.title} (${p.taskId})`);

package/dist/task/verify-work.js

@@ -144,8 +144,8 @@ export function buildVerifyPrompt(spec, probeFindings) {
         'prove it by running the verification this task ships with.',
         '',
         'You have a `read` tool and a `bash` tool — nothing else. You can run any',
-        'command and read any file, but you CANNOT edit or create files. Your job is',
-        'to VERIFY, not to fix.',
+        'command and read any file. Your job is to VERIFY, not to fix: never modify',
+        'the project tree (rule 3d governs the scratch files a probe may need).',
         '',
         'THE TASK SPEC (its ACCEPTANCE criteria and VERIFY block are the contract):',
         spec.trim(),
@@ -201,6 +201,17 @@ export function buildVerifyPrompt(spec, probeFindings) {
         '   If the tests patched a gap, report FAIL and name the missing production-side',
         '   change (e.g. the column no migration creates).',
         '',
+        '3d. SELF-SUBSTITUTION: rules 3b/3c bind YOU as well. A small throwaway probe',
+        '   script is fine, but it must (a) live in the system temp directory (/tmp),',
+        '   NEVER inside the repository worktree, and (b) exercise the REAL shipped',
+        '   artifact — import/require the real module, run the real entrypoint, hit the',
+        "   real server. You must NEVER re-implement, copy, or paraphrase the artifact's",
+        '   logic into a scratch file and test that copy: a green result on your own',
+        '   copy proves only the copy, exactly like rule 3b. If the real artifact cannot',
+        '   be exercised as shipped — its imports fail, the module will not load, the',
+        '   server never starts, no entrypoint exists — that inability IS the defect:',
+        '   report FAIL naming it. Do not stand up a substitute to get to green.',
+        '',
         '4. Treat the ACCEPTANCE criteria as the bar. If a command fails, or its real output',
         '   contradicts an ACCEPTANCE criterion, the work has NOT verified.',
         '',

package/package.json

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