@mjasnikovs/pi-task 0.18.19 → 0.18.20

package/dist/task/auto-orchestrator.js

@@ -42,7 +42,19 @@ import { LAUNCH_EXTRACT_PROMPT, enumerateScriptCandidates, parseScriptLines, kee
 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.
+// while a judge that keeps flagging can't loop the plan phase forever. Each round
+// spawns three model children (decompose + coverage-map + coverage-verdict), so
+// the ceiling is also a latency/spawn budget, not just a correctness bound.
+//
+// Why 2 is safe to sit this low: when this number was picked (2026-07-03) adoption
+// was LAST-WINS, so more rounds meant more chances to overwrite a good plan with a
+// worse regeneration — the cap was protective. Adoption is now MONOTONE
+// (coverage-loop.ts, 2026-07-15): a retry that drops owned coverage is rejected,
+// never adopted, so extra rounds can only hold or grow coverage. The one gap that
+// remained is that an adoption landing ON the last round can expose a NEW area with
+// no round left to chase it — handled surgically by a single bonus round granted
+// only in that exact case (see the loop), rather than by raising this ceiling for
+// every run.
 const MAX_COVERAGE_ROUNDS = 2;
 /** Reprompt prefix when the coverage triage found feature areas no task covers. */
 function coverageRepromptHint(missing) {
@@ -106,6 +118,17 @@ function logPlanDebug(cwd, msg) {
         .then(() => fsp.appendFile(path.join(dir, 'plan-debug.log'), line))
         .catch(() => { });
 }
+/** Normalise a missing-area string for cross-round identity — lowercased alnum
+ *  words, punctuation and quote-wrapping collapsed. Used only to tell whether an
+ *  adopted plan introduced a NEW gap versus re-surfacing the same one (#2 bonus
+ *  round); intentionally coarse, so trivial rewording of the same area does not
+ *  read as new and buy an extra round. */
+function normMissingArea(s) {
+    return s
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .trim();
+}
 /**
  * Clarify's answer-side TRIAGE — the second stage /task-auto's clarify gate was
  * missing that /task's grill already had. /task-auto's clarify was single-stage:
@@ -569,7 +592,8 @@ export async function planAuto(ctx, cwd, feature, deps) {
         return {
             plan: { titles, covered, missing },
             accounting: acc,
-            suspect: isSuspectPlan(titles, featureForModel)
+            suspect: isSuspectPlan(titles, featureForModel),
+            judgeMissing: verdictMissing
         };
     };
     const hasRequirements = reqEntries.length > 0;
@@ -579,6 +603,17 @@ export async function planAuto(ctx, cwd, feature, deps) {
     // The carried accounting (cross-cutting + unowned) for the plan that ships.
     let accounting = best.accounting;
     let round = 0;
+    // #2: the round cap can be lifted ONCE. An adoption is a fresh whole-plan roll,
+    // so the plan that gets adopted can expose an uncovered area the pre-adoption
+    // plan never had — and if that adoption lands on the last allowed round, the
+    // loop breaks before the new gap ever gets a reprompt (mx5 2026-07-16: the
+    // 55-title plan was adopted on the final round AND was the first to reveal §10's
+    // test-infra gap; the cap fired the same instant, so it was never chased). Grant
+    // exactly one bonus round when — and only when — an adoption introduces a NEW
+    // missing area at the cap. Bounded to one so a judge that flags forever still
+    // cannot loop the plan phase; a persistent (non-new) gap never re-triggers it.
+    let roundCap = MAX_COVERAGE_ROUNDS;
+    let bonusRoundUsed = false;
     for (;;) {
         if (best.plan.titles.length === 0)
             break;
@@ -596,7 +631,7 @@ export async function planAuto(ctx, cwd, feature, deps) {
             }
             break;
         }
-        if (round >= MAX_COVERAGE_ROUNDS)
+        if (round >= roundCap)
             break;
         round++;
         logPlanDebug(cwd, `decompose-coverage round ${round}: INCOMPLETE — missing: `
@@ -606,9 +641,29 @@ export async function planAuto(ctx, cwd, feature, deps) {
         const cand = await scorePlan(retryTitles);
         const decision = decideAdoption(best.plan, cand.plan, hasRequirements);
         if (decision.adopt) {
+            // Snapshot the pre-adoption plan to decide whether this adoption earns a
+            // bonus round. Two guards keep the bonus off generic judge churn: it must
+            // be a real coverage GAIN (grounded covered-set strictly grew — a flaky
+            // judge that just relabels the same-shaped plan's gap does not qualify),
+            // and it must expose a NEW area (a gap already present is one we have or
+            // will reprompt against anyway). Requirements-path only: without grounded
+            // requirements "missing" is pure holistic-judge free-text that can change
+            // every round, so there is no trustworthy "grew"/"new" signal to gate on.
+            const priorCovered = best.plan.covered.size;
+            const priorMissing = new Set(best.plan.missing.map(normMissingArea));
             best = cand;
             accounting = cand.accounting ?? accounting;
             logPlanDebug(cwd, `decompose retry ADOPTED — ${decision.reason}`);
+            if (!bonusRoundUsed
+                && round >= roundCap
+                && hasRequirements
+                && cand.plan.covered.size > priorCovered
+                && cand.plan.missing.some(m => !priorMissing.has(normMissingArea(m)))) {
+                bonusRoundUsed = true;
+                roundCap++;
+                logPlanDebug(cwd, 'decompose-coverage: bonus round granted — adoption grew coverage and '
+                    + 'exposed a new uncovered area at the cap');
+            }
         }
         else {
             // Rejected: keep the better current plan. The loop re-checks it at the
@@ -631,7 +686,10 @@ export async function planAuto(ctx, cwd, feature, deps) {
     if (unresolvedMissing !== null) {
         logPlanDebug(cwd, `decompose-coverage exhausted ${round} 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');
+        ctx.ui.notify(`/task-auto: no task fully owns — ${unresolvedMissing.join('; ').slice(0, 200)}. `
+            + 'Carried into every task via .pi-tasks/requirements.md, but not as a dedicated '
+            + 'task. To give it one, stop now and add it to the plan in .pi-tasks/; otherwise '
+            + 'it proceeds.', 'warning');
     }
     // Carry what no single task owns (goal A(b)/(c)): cross-cutting requirements
     // become `.pi-tasks/requirements.md`, injected VERBATIM into every task's
@@ -639,15 +697,25 @@ export async function planAuto(ctx, cwd, feature, deps) {
     // is authoritative" pointer recovered it in 1 of ~6 tasks; content travels,
     // pointers don't). Requirements still unmapped after the rounds are carried
     // too — marked — and recorded user-visibly in the plan file, never dropped.
-    if (accounting !== null) {
-        await appendCarriedRequirements(cwd, accounting.crossCutting, accounting.unmapped);
-        if (accounting.crossCutting.length > 0 || accounting.unmapped.length > 0) {
-            ctx.ui.notify(`/task-auto: carrying ${accounting.crossCutting.length} cross-cutting`
-                + (accounting.unmapped.length > 0 ?
-                    ` and ${accounting.unmapped.length} unowned`
-                    : '')
-                + ' requirement(s) into every task — see .pi-tasks/requirements.md.', 'info');
-        }
+    //
+    // #1: the holistic-judge missing areas are carried as a THIRD channel. They are
+    // areas requirement-extraction never captured as a tracked entry (so the
+    // grounded accounting is structurally blind to them), seen only by the judge —
+    // exactly the class that, having no carrier, was warned-about then dropped (mx5
+    // 2026-07-16, §10 test-infra). Carried independent of `accounting` so a mapping
+    // fault (accounting === null) can't strand them either.
+    const carriedCrossCutting = accounting?.crossCutting ?? [];
+    const carriedUnmapped = accounting?.unmapped ?? [];
+    const carriedJudge = best.judgeMissing;
+    if (carriedCrossCutting.length > 0 || carriedUnmapped.length > 0 || carriedJudge.length > 0) {
+        await appendCarriedRequirements(cwd, carriedCrossCutting, carriedUnmapped, carriedJudge);
+        const parts = [
+            carriedCrossCutting.length > 0 ? `${carriedCrossCutting.length} cross-cutting` : '',
+            carriedUnmapped.length > 0 ? `${carriedUnmapped.length} unowned` : '',
+            carriedJudge.length > 0 ? `${carriedJudge.length} judge-flagged` : ''
+        ].filter(p => p.length > 0);
+        ctx.ui.notify(`/task-auto: carrying ${parts.join(', ')} requirement(s) into every task`
+            + ' — see .pi-tasks/requirements.md.', 'info');
     }
     // Cross-slice contract registry (mx5 run 8, F3): now that the plan is settled,
     // extract the interface facts MORE THAN ONE slice must agree on — endpoint paths,

package/dist/task/coverage-loop.js

@@ -32,17 +32,106 @@
 // domain-agnostic (no mx5/web vocabulary).
 const COVERAGE_STOPWORDS = new Set([
     // function words
-    'the', 'a', 'an', 'and', 'or', 'of', 'to', 'in', 'on', 'for', 'with', 'by', 'at', 'as', 'is',
-    'are', 'be', 'it', 'its', 'that', 'this', 'from', 'into', 'out', 'up', 'per', 'via', 'not', 'no',
-    'but', 'if', 'then', 'than', 'so', 'such', 'each', 'any', 'all', 'every', 'when', 'where', 'must',
-    'should', 'shall', 'may', 'can', 'will', 'end', 'new',
+    'the',
+    'a',
+    'an',
+    'and',
+    'or',
+    'of',
+    'to',
+    'in',
+    'on',
+    'for',
+    'with',
+    'by',
+    'at',
+    'as',
+    'is',
+    'are',
+    'be',
+    'it',
+    'its',
+    'that',
+    'this',
+    'from',
+    'into',
+    'out',
+    'up',
+    'per',
+    'via',
+    'not',
+    'no',
+    'but',
+    'if',
+    'then',
+    'than',
+    'so',
+    'such',
+    'each',
+    'any',
+    'all',
+    'every',
+    'when',
+    'where',
+    'must',
+    'should',
+    'shall',
+    'may',
+    'can',
+    'will',
+    'end',
+    'new',
     // generic task verbs
-    'add', 'implement', 'create', 'build', 'scaffold', 'setup', 'set', 'support', 'handle', 'apply',
-    'use', 'used', 'using', 'make', 'makes', 'made', 'enable', 'provide', 'ensure', 'allow', 'run',
-    'runs', 'get', 'gets', 'define', 'configure', 'init', 'update', 'manage',
+    'add',
+    'implement',
+    'create',
+    'build',
+    'scaffold',
+    'setup',
+    'set',
+    'support',
+    'handle',
+    'apply',
+    'use',
+    'used',
+    'using',
+    'make',
+    'makes',
+    'made',
+    'enable',
+    'provide',
+    'ensure',
+    'allow',
+    'run',
+    'runs',
+    'get',
+    'gets',
+    'define',
+    'configure',
+    'init',
+    'update',
+    'manage',
     // generic project nouns
-    'cli', 'tool', 'app', 'application', 'project', 'feature', 'task', 'tasks', 'user', 'users',
-    'mode', 'flag', 'flags', 'option', 'options', 'system', 'code', 'thing', 'things', 'work'
+    'cli',
+    'tool',
+    'app',
+    'application',
+    'project',
+    'feature',
+    'task',
+    'tasks',
+    'user',
+    'users',
+    'mode',
+    'flag',
+    'flags',
+    'option',
+    'options',
+    'system',
+    'code',
+    'thing',
+    'things',
+    'work'
 ]);
 /** Distinctive content tokens of a phrase: lowercased alphanumeric words ≥3 chars,
  *  minus the ubiquitous stopwords. `--json` → `json`, `dead-letter` → `dead`,`letter`.

package/dist/task/requirements.d.ts

@@ -76,11 +76,20 @@ export declare function accountCoverage(requirements: RequirementEntry[], mappin
 /** The stored carried-requirements text ('' when none recorded). */
 export declare function readRequirements(cwd: string): Promise<string>;
 /**
- * Append carried requirements (cross-cutting, plus any left unmapped after the
- * retry rounds — better carried into every task than silently lost), deduped
- * against what is stored. Host-side only; children never write it. Best-effort.
+ * Append carried requirements, deduped against what is stored. Three channels,
+ * each better carried into every task than silently lost — host-side only,
+ * children never write it, best-effort:
+ *   • `crossCutting` — obligations no single task owns (policy/global rules).
+ *   • `unresolved`   — grounded requirements still unmapped after the retry rounds.
+ *   • `judgeFlagged` — free-text areas the holistic coverage judge flagged as
+ *     uncovered that requirement-extraction never captured as a tracked entry, so
+ *     the grounded channels above are structurally blind to them (mx5 2026-07-16:
+ *     §10's test-infra setup was seen ONLY by the judge and, having no carrier,
+ *     was warned-about then dropped). These are plain strings, not quotes of the
+ *     source; marked distinctly so a task can tell an inferred area from a verbatim
+ *     obligation.
  */
-export declare function appendCarriedRequirements(cwd: string, crossCutting: RequirementEntry[], unresolved?: RequirementEntry[]): Promise<void>;
+export declare function appendCarriedRequirements(cwd: string, crossCutting: RequirementEntry[], unresolved?: RequirementEntry[], judgeFlagged?: string[]): Promise<void>;
 /**
  * The read-only block refine/compose receive when carried requirements exist.
  * Verbatim content travels with every task (the directive pattern that works),

package/dist/task/requirements.js

@@ -308,12 +308,21 @@ function formatEntry(e, marker) {
     return `"${e.quote}"${anchor}${marker ? ` [${marker}]` : ''}`;
 }
 /**
- * Append carried requirements (cross-cutting, plus any left unmapped after the
- * retry rounds — better carried into every task than silently lost), deduped
- * against what is stored. Host-side only; children never write it. Best-effort.
+ * Append carried requirements, deduped against what is stored. Three channels,
+ * each better carried into every task than silently lost — host-side only,
+ * children never write it, best-effort:
+ *   • `crossCutting` — obligations no single task owns (policy/global rules).
+ *   • `unresolved`   — grounded requirements still unmapped after the retry rounds.
+ *   • `judgeFlagged` — free-text areas the holistic coverage judge flagged as
+ *     uncovered that requirement-extraction never captured as a tracked entry, so
+ *     the grounded channels above are structurally blind to them (mx5 2026-07-16:
+ *     §10's test-infra setup was seen ONLY by the judge and, having no carrier,
+ *     was warned-about then dropped). These are plain strings, not quotes of the
+ *     source; marked distinctly so a task can tell an inferred area from a verbatim
+ *     obligation.
  */
-export async function appendCarriedRequirements(cwd, crossCutting, unresolved = []) {
-    if (crossCutting.length === 0 && unresolved.length === 0)
+export async function appendCarriedRequirements(cwd, crossCutting, unresolved = [], judgeFlagged = []) {
+    if (crossCutting.length === 0 && unresolved.length === 0 && judgeFlagged.length === 0)
         return;
     try {
         const existing = (await readRequirements(cwd)).split('\n').filter(l => l.trim().length > 0);
@@ -324,7 +333,11 @@ export async function appendCarriedRequirements(cwd, crossCutting, unresolved =
         const merged = [...existing];
         for (const [entries, marker] of [
             [crossCutting, undefined],
-            [unresolved, 'no task owns this — surfaced at plan time']
+            [unresolved, 'no task owns this — surfaced at plan time'],
+            [
+                judgeFlagged.map(q => ({ quote: q, anchor: '' })),
+                'judge-flagged uncovered area, no task owns this — surfaced at plan time'
+            ]
         ]) {
             for (const e of entries) {
                 const key = normalise(e.quote);

package/package.json

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