@mjasnikovs/pi-task 0.18.40 → 0.18.41

package/dist/task/auto-orchestrator.js

@@ -39,6 +39,7 @@ import { isYoloMode, yoloPickAnswer, yoloFinalGateChoice, YOLO_STAMP } from './y
 import { configureResearchRun, resumeResearchRun } from '../workers/research-cache.js';
 import { CONTRACT_EXTRACT_PROMPT, parseContractLines, keepGroundedContracts, appendContracts } from './contracts.js';
 import { reconcileTitleSources } from './decompose-fidelity.js';
+import { mandatesTestsInSameChange, rewriteBatchTestPlan } from './batch-test-task.js';
 import { REQUIREMENT_EXTRACT_PROMPT, COVERAGE_MAP_PROMPT, parseRequirementLines, keepGroundedRequirements, capRequirements, enumerateObligationPassages, uncoveredPassages, extractionRetryHint, parseCoverageMap, accountCoverage, isCrossCuttingRequirement, appendCarriedRequirements, buildRequirementsLedger } from './requirements.js';
 import { decideAdoption, groundedCoverage } from './coverage-loop.js';
 import { findSpecDanglingArtifacts, titlesCoverArtifact, danglingMissingText, danglingCarryText } from './artifact-closure.js';
@@ -590,8 +591,18 @@ export async function planAuto(ctx, cwd, feature, deps) {
     catch {
         // best-effort channel
     }
+    // Tests-in-the-same-change cadence (mx5 run 14, PROMPT item 6): when the
+    // decisions mandate it, a whole-project batch test task contradicts them —
+    // run 14 shipped one anyway (TASK_0037, 4.7h, yolo-accepted FAIL) because
+    // decompose mirrors the spec's milestone shape. The decisions channel
+    // OVERRIDES the spec doc, so this resolves toward the decision without asking.
+    const noBatchTests = mandatesTestsInSameChange(clarifications, featureForModel);
+    if (noBatchTests) {
+        logPlanDebug(cwd, 'decisions mandate tests-in-the-same-change — batch test tasks are banned '
+            + 'from this plan (prompt rule + host rewrite)');
+    }
     // decompose
-    const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications, buildRequirementsLedger(reqEntries));
+    const decomposePrompt = AUTO_DECOMPOSE_PROMPT(featureForModel, clarifications, buildRequirementsLedger(reqEntries), noBatchTests);
     // Parse + FIDELITY RECONCILIATION (mx5 run 11, goal B): ground each title's
     // [source: "…"] citation against the doc, strip the clause, and re-attach any
     // `+`-joined constraint fragment the paraphrased title dropped (the silently
@@ -606,7 +617,18 @@ export async function planAuto(ctx, cwd, feature, deps) {
                     .map(r => ` [task ${r.index + 1}: ${r.fragments.join(', ')}]`)
                     .join(''));
         }
-        return plan.titles;
+        // Batch-test ban (item 6): drop or scope a whole-project "write all the
+        // tests" task. Identity unless the cadence decision is present, and the
+        // sweep replacement re-grounds every requirement the drop would cost — so
+        // planned coverage cannot fall (run 12's lesson).
+        const debatched = rewriteBatchTestPlan(plan.titles, clarifications, featureForModel, reqEntries.map(e => e.quote), isCrossCuttingRequirement);
+        for (const a of debatched.actions) {
+            logPlanDebug(cwd, `batch test task ${a.kind} (tests-in-same-change decision): "${a.title}"`
+                + (a.kind === 'scoped' ?
+                    ` → scoped sweep over ${a.orphaned.length} orphaned requirement(s)`
+                    : ' — every requirement it touched is owned by another task'));
+        }
+        return debatched.titles;
     };
     const listRaw = await deps.runChild('auto-decompose', 'read', decomposePrompt);
     let planTitles = parsePlan(listRaw);

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

@@ -12,8 +12,12 @@ export declare const AUTO_CLARIFY_PROMPT: (feature: string, priorQA: string) =>
  * belt): the spec's obligations ride into decompose explicitly, so mirroring the
  * spec's own milestone/section structure cannot silently discharge them. '' ⇒
  * the prompt is unchanged.
+ *
+ * `noBatchTests` adds the anti-batch-test rule (batch-test-task.ts) — emitted ONLY
+ * when the decisions mandate tests-in-the-same-change, so every other run sees the
+ * prompt it always saw. It is the belt; the host-side rewrite is the lever.
  */
-export declare const AUTO_DECOMPOSE_PROMPT: (feature: string, clarifications: string, requirementsLedger?: string) => string;
+export declare const AUTO_DECOMPOSE_PROMPT: (feature: string, clarifications: string, requirementsLedger?: string, noBatchTests?: boolean) => string;
 /**
  * Coverage triage: judge whether a decomposed task list covers the whole
  * feature. Guards the plan — the highest-leverage artifact in /task-auto —

package/dist/task/auto-prompts.js

@@ -3,6 +3,7 @@
  * LIST only; all research/spec depth is /task's job, run per-title later.
  */
 import { DECOMPOSE_SOURCE_RULE } from './decompose-fidelity.js';
+import { DECOMPOSE_NO_BATCH_TESTS_RULE } from './batch-test-task.js';
 /**
  * Clarify: asks ONE question at a time. Output MUST match parseClarifyList — a
  * single numbered question followed by a "SUGGESTED: <default>" line, an optional
@@ -71,8 +72,12 @@ NONE`;
  * belt): the spec's obligations ride into decompose explicitly, so mirroring the
  * spec's own milestone/section structure cannot silently discharge them. '' ⇒
  * the prompt is unchanged.
+ *
+ * `noBatchTests` adds the anti-batch-test rule (batch-test-task.ts) — emitted ONLY
+ * when the decisions mandate tests-in-the-same-change, so every other run sees the
+ * prompt it always saw. It is the belt; the host-side rewrite is the lever.
  */
-export const AUTO_DECOMPOSE_PROMPT = (feature, clarifications, requirementsLedger = '') => `Split this feature into an ordered list of implementation tasks. Each task
+export const AUTO_DECOMPOSE_PROMPT = (feature, clarifications, requirementsLedger = '', noBatchTests = false) => `Split this feature into an ordered list of implementation tasks. Each task
 will be handed, by its title, to a separate pipeline that does its own research
 and writes its own spec — so here you produce TITLES ONLY, not specs.
 
@@ -94,7 +99,7 @@ RULES:
   none. These are explicit user choices that may contradict the referenced spec
   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.
-${DECOMPOSE_SOURCE_RULE}
+${DECOMPOSE_SOURCE_RULE}${noBatchTests ? `\n${DECOMPOSE_NO_BATCH_TESTS_RULE}` : ''}
 - Output the checkbox list and NOTHING else (no preamble, no numbering).`;
 /**
  * Coverage triage: judge whether a decomposed task list covers the whole

package/dist/task/batch-test-task.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Does the decisions/spec text mandate tests-in-the-same-change?
+ *
+ * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so
+ * a testing section that happens to sit near an unrelated "don't defer" line
+ * cannot trigger the ban. `decisions` is checked first and alone is sufficient;
+ * the spec is scanned too because run 14's cadence rule is stated in §10 of the
+ * doc and only echoed into the decisions channel.
+ */
+export declare function mandatesTestsInSameChange(decisions: string, spec?: string): boolean;
+/**
+ * Indices of titles that are whole-project BATCH test tasks.
+ *
+ * Three conditions must all hold — the title's deliverable is tests, its scope is
+ * the whole project, and it is not test INFRASTRUCTURE. A per-feature task that
+ * carries "+ tests" never matches (its head names the feature), which is the
+ * point: those are the cadence the decision asks for.
+ */
+export declare function findBatchTestTitles(titles: string[]): number[];
+/**
+ * The spec's own coverage source — the command whose report scopes the sweep.
+ *
+ * Only backticked spans are considered, so the result is a command the spec
+ * actually writes down rather than a phrase inferred from prose; a span carrying
+ * a coverage flag wins over a plain test run. Falls back to a generic phrase when
+ * the spec names no command, which keeps the sweep title well-formed either way.
+ */
+export declare function coverageSourceFromSpec(spec: string): string;
+/**
+ * The scoped replacement: a gap-filling sweep, bounded by what the coverage
+ * source reports and by the requirements that lost their only owner. It states
+ * the ban explicitly, because the child that receives this title sees nothing
+ * else.
+ */
+export declare function buildSweepTitle(orphaned: string[], coverageSource: string): string;
+export interface BatchTestAction {
+    /** Index of the offending title in the INPUT list. */
+    index: number;
+    /** The offending title, verbatim. */
+    title: string;
+    kind: 'dropped' | 'scoped';
+    /** The sweep title that replaced it (`kind: 'scoped'` only). */
+    replacement?: string;
+    /** Requirement quotes that no OTHER title grounds — what the sweep must cover. */
+    orphaned: string[];
+}
+export interface BatchTestRewrite {
+    titles: string[];
+    actions: BatchTestAction[];
+}
+/**
+ * Rewrite a decomposed plan so it carries no whole-project batch test task when
+ * the decisions mandate tests-in-the-same-change.
+ *
+ * No mandate, or no batch title ⇒ the plan is returned untouched (identity), so
+ * every non-cadence run behaves exactly as before.
+ *
+ * With a mandate, ALL batch titles are removed at once before coverage is
+ * re-measured — otherwise two batch tasks would each mask the other's orphans and
+ * both would look droppable. The orphaned set is then whatever grounded coverage
+ * the removal costs; it is non-empty only when no other task's title claims that
+ * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted (in
+ * the first batch title's position, so plan order is preserved).
+ */
+export declare function rewriteBatchTestPlan(titles: string[], decisions: string, spec: string, requirementQuotes: string[], isCrossCutting: (quote: string) => boolean): BatchTestRewrite;
+/**
+ * The decompose-prompt rule (the belt; the host rewrite above is the lever).
+ * Emitted ONLY when the decisions mandate the cadence, so ordinary runs see the
+ * prompt they always saw. Kept next to the detector so the two cannot drift.
+ */
+export declare const DECOMPOSE_NO_BATCH_TESTS_RULE: string;

package/dist/task/batch-test-task.js

@@ -0,0 +1,320 @@
+/**
+ * batch-test-task — ban the whole-project "write all the tests" task when the
+ * DECISIONS channel mandates tests-in-the-same-change (mx5 run 14, PROMPT item 6).
+ *
+ * The failure this closes: run 14's plan contained
+ *
+ *   TASK_0037  "Write component and page tests — Playwright CT tests with
+ *               screenshot baselines for all components and pages"
+ *
+ * — ~4.7h, the worst active-time task of the run, ended in a yolo-accepted verify
+ * FAIL with a frozen-config violation — while the very decision carried ON THAT
+ * TITLE said the opposite:
+ *
+ *   "a test lands *as fast as possible* — in the same change — as each new route
+ *    or React component/page. No route or component is considered done until its
+ *    test exists and passes. Don't batch testing to the end of a milestone."
+ *
+ * Decompose did not invent the shape: the spec's own §10/§12 structure induced it,
+ * and decompose mirrors the spec. So the conflict is SPEC-INTERNAL (the spec's
+ * milestone shape vs the spec's own cadence rule), and the decisions channel
+ * OVERRIDES the spec doc by definition — the same precedence the task titles
+ * already state. Resolve toward the decision; never ask the user.
+ *
+ * The mechanism is a deterministic post-decompose rewrite (applied on EVERY
+ * decompose output, like fidelity reconciliation), plus a conditional prompt rule
+ * as the belt. Only the batch-EVERYTHING shape is banned — coverage is never
+ * nuked (run 12's lesson). Which of the two outcomes fires is decided by
+ * `groundedCoverage`, not by wording:
+ *
+ *   • the batch title grounds NO requirement that survives its removal ⇒ every
+ *     requirement it touched is owned by some other task, the per-change cadence
+ *     already covers the work, and the task is DROPPED;
+ *   • it is the ONLY title grounding some requirement(s) ⇒ dropping it would
+ *     reduce planned coverage, so it is REPLACED by a scoped sweep that names
+ *     exactly those orphaned requirements and points at the spec's own coverage
+ *     source ("fill the gaps <that command> reports"), never "test everything".
+ *
+ * Because the replacement's owned-set is computed from the same groundedCoverage
+ * the monotonic adoption guard uses, total planned coverage cannot fall.
+ */
+import { groundedCoverage } from './coverage-loop.js';
+/**
+ * Sentences that MANDATE tests landing with the change they cover. Deliberately
+ * narrow: a spec that merely REQUIRES tests ("every route has tests") does not
+ * ban a batch task — only an explicit cadence/anti-batch directive does.
+ */
+const SAME_CHANGE_RE = /\bin the same (?:change|commit|pr|patch|diff|task|step)\b|\b(?:do ?n['’]?t|do not|never|no)\s+(?:batch|defer|postpone|save|leave)\b|\bnot\b[^.]{0,60}\bdone until\b[^.]{0,60}\btest/i;
+/** Any mention of testing — the mandate must be ABOUT tests, not about docs. */
+const TEST_WORD_RE = /\btests?\b|\btesting\b|\btest-first\b/i;
+/**
+ * Does the decisions/spec text mandate tests-in-the-same-change?
+ *
+ * Scans sentence by sentence and requires BOTH signals in the SAME sentence, so
+ * a testing section that happens to sit near an unrelated "don't defer" line
+ * cannot trigger the ban. `decisions` is checked first and alone is sufficient;
+ * the spec is scanned too because run 14's cadence rule is stated in §10 of the
+ * doc and only echoed into the decisions channel.
+ */
+export function mandatesTestsInSameChange(decisions, spec = '') {
+    for (const text of [decisions, spec]) {
+        for (const sentence of text.split(/(?<=[.!?])\s+|\n{2,}/)) {
+            if (TEST_WORD_RE.test(sentence) && SAME_CHANGE_RE.test(sentence))
+                return true;
+        }
+    }
+    return false;
+}
+/** Trailing `[decisions: …]` clauses decompose appends — carried onto the
+ *  replacement title verbatim so the rewrite never loses a directive. */
+const DECISIONS_CLAUSE_RE = /\s*\[decisions:/i;
+/**
+ * Where decompose's trailing metadata starts. `[source: …]` is included because
+ * reconcileTitleSources only strips a WELL-FORMED trailing citation: measured
+ * live, the model also emits `[source: "…" [10. Testing]]`, which fails that
+ * regex and leaks the QUOTED SPEC LINE into the title. Judging scope on such a
+ * title reads the citation's words as the task's own — the cadence quote "…as
+ * each new route or React component/page" made a properly scoped
+ * "Write route/API tests for auth" look like a batch task (live false positive,
+ * rep 1). A citation is provenance, never scope.
+ */
+const CLAUSE_START_RE = /\s*\[(?:source|decisions)\s*:/i;
+/** Split a title into the part decompose authored, and the `[decisions: …]` tail
+ *  that must survive onto a replacement title. A leaked `[source: …]` remnant is
+ *  dropped from both — the sweep does not derive from that line. */
+function splitDecisions(title) {
+    const clause = CLAUSE_START_RE.exec(title);
+    const body = (clause ? title.slice(0, clause.index) : title).trim();
+    const decisions = DECISIONS_CLAUSE_RE.exec(title);
+    return { body, tail: decisions ? title.slice(decisions.index) : '' };
+}
+/** The head of a title: everything before the " — <detail>" separator. */
+function head(body) {
+    return body.split(/\s+[—–-]\s+|\s*\|\s*/)[0];
+}
+/**
+ * Remove double-quoted spans — they are QUOTED SPEC TEXT, never the task's own
+ * scope. Measured live: the model frequently appends its citation as a bare
+ * quote with no `[source: …]` wrapper ("Write auth route tests — … — "…a test
+ * lands as fast as possible — in the same change — as each new route or React
+ * component/page.""), and that borrowed "each" made five correctly scoped
+ * per-area test tasks read as batch tasks (rep 5). Trading a possible miss (a
+ * batch title whose only quantifier sits inside a quote) for never deleting a
+ * properly scoped test task: the false positive is far the more expensive error.
+ */
+function stripQuotedSpans(s) {
+    return s.replace(/"[^"]*"/g, ' ').replace(/[“][^”]*[”]/g, ' ');
+}
+/** A title whose DELIVERABLE is tests: an authoring verb whose object is tests,
+ *  with nothing else claimed in between ("Write component and page tests" ✓,
+ *  "Add listings CRUD + tests" ✗ — the `+` marks tests as an additive constraint
+ *  on a feature task, which is exactly the cadence the decision asks for). */
+const TEST_AUTHORING_RE = /^\s*(?:(?:write|add|create|implement|author|build|develop|produce|backfill)\b[\w\s,/-]*\b(?:tests?|test suite|test coverage|testing)\b|(?:tests?|testing)\b)/i;
+/** Enabling/infrastructure work — a runner, a config, fixtures, CI. Those are
+ *  NOT batched test authoring; banning them would remove the very thing the
+ *  per-change tests need to exist first. */
+const TEST_INFRA_RE = /\b(?:harness|infrastructure|infra|runner|config|configuration|scaffold|scaffolding|set ?up|fixtures?|helpers?|utilities|utility|ci|pipeline|database|seed)\b/i;
+/**
+ * WHOLE-PROJECT scope: a universal quantifier that governs a PROJECT-LEVEL target
+ * ("all components and pages", "every route"), not merely any noun.
+ *
+ * Both halves are load-bearing, each learned from a live false positive:
+ *   - "full"/"complete" are excluded — they routinely scope a single area
+ *     ("full login flow");
+ *   - the quantifier must reach a project-level plural within ~20 chars, because
+ *     "Test PartCard component — ALL badge combinations…" is a one-component task
+ *     that a bare-quantifier rule flagged and DROPPED (live rep 3).
+ */
+const WHOLE_SCOPE_RE = /\b(?:all|every|each|entire|whole|comprehensive)\b[\w\s,/-]{0,20}?\b(?:components?|pages?|routes?|endpoints?|screens?|views?|modules?|layers?|files?|features?|app|application|project|codebase|repo|repository|system|surface)\b|\bacross the (?:app|application|project|codebase|repo|repository)\b|\bend[- ]to[- ]end coverage\b/i;
+/**
+ * Indices of titles that are whole-project BATCH test tasks.
+ *
+ * Three conditions must all hold — the title's deliverable is tests, its scope is
+ * the whole project, and it is not test INFRASTRUCTURE. A per-feature task that
+ * carries "+ tests" never matches (its head names the feature), which is the
+ * point: those are the cadence the decision asks for.
+ */
+export function findBatchTestTitles(titles) {
+    const out = [];
+    for (let i = 0; i < titles.length; i++) {
+        const { body } = splitDecisions(titles[i]);
+        const scope = stripQuotedSpans(body);
+        const h = head(scope);
+        if (!TEST_AUTHORING_RE.test(h))
+            continue;
+        if (TEST_INFRA_RE.test(h))
+            continue;
+        if (!WHOLE_SCOPE_RE.test(scope))
+            continue;
+        out.push(i);
+    }
+    return out;
+}
+/** Test-runner commands a spec may name as the thing that REPORTS coverage. */
+const TEST_COMMAND_RE = /\b(?:bun test|npm (?:run )?test|yarn test|pnpm (?:run )?test|npx (?:vitest|jest|playwright test)|playwright test|vitest|jest|pytest|go test|cargo test|mix test|rspec)\b[^`\n]*/i;
+/**
+ * The spec's own coverage source — the command whose report scopes the sweep.
+ *
+ * Only backticked spans are considered, so the result is a command the spec
+ * actually writes down rather than a phrase inferred from prose; a span carrying
+ * a coverage flag wins over a plain test run. Falls back to a generic phrase when
+ * the spec names no command, which keeps the sweep title well-formed either way.
+ */
+export function coverageSourceFromSpec(spec) {
+    const spans = [...spec.matchAll(/`([^`\n]+)`/g)].map(m => m[1].trim());
+    const commands = spans.filter(s => TEST_COMMAND_RE.test(s));
+    const withCoverage = commands.find(s => /--coverage|\bcoverage\b/i.test(s));
+    return withCoverage ?? commands[0] ?? "the project's own test suite";
+}
+/**
+ * Vocabulary that every testing task and every testing requirement shares, so it
+ * carries NO ownership signal here. Without this scrub the bare token "test"
+ * connects a screenshot-baseline requirement to "Write auth route tests", and the
+ * orphan check goes blind. (Scrubbed locally rather than added to
+ * COVERAGE_STOPWORDS: those govern the A/B-validated monotonic adoption guard,
+ * where "test" IS a discriminating noun for a plan that has no testing task at
+ * all.) Token-level, not regex — `mx5_test` must scrub to `mx5`.
+ */
+const GENERIC_TEST_TOKENS = new Set([
+    'test',
+    'tests',
+    'testing',
+    'tested',
+    'spec',
+    'specs',
+    'suite',
+    'suites',
+    'coverage',
+    'assertion',
+    'assertions',
+    'case',
+    'cases',
+    'unit',
+    'e2e'
+]);
+/** Drop the generic testing vocabulary, keeping the tokenization coverage-loop
+ *  itself uses so the scrubbed text grounds exactly the same way. */
+function scrubTestVocabulary(s) {
+    return s
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .filter(w => w.length > 0 && !GENERIC_TEST_TOKENS.has(w))
+        .join(' ');
+}
+/**
+ * Requirement indices that lose their owner when the batch titles are removed.
+ *
+ * Two independent measures, unioned:
+ *
+ *   1. STRICT (the one that actually fires): generic testing vocabulary scrubbed
+ *      from both sides, and a requirement that is ABOUT testing may only be owned
+ *      by a title that is about testing — "Implement login page" does not
+ *      discharge "every component/page test captures a screenshot".
+ *   2. PLAIN groundedCoverage, exactly as the monotonic adoption guard measures
+ *      it. This is the belt: whatever that guard would call a drop is an orphan
+ *      here too, so the rewrite can never trip the guard it feeds.
+ */
+function orphanedRequirements(quotes, titles, kept, isCrossCutting) {
+    const scrubbed = quotes.map(scrubTestVocabulary);
+    // Index-aligned cross-cutting lookup: the scrubbed text is not the quote the
+    // classifier expects, so map back to the original.
+    const crossByScrub = new Map();
+    quotes.forEach((q, i) => crossByScrub.set(scrubbed[i], isCrossCutting(q)));
+    const isCrossScrubbed = (s) => crossByScrub.get(s) ?? false;
+    const testish = (t) => TEST_WORD_RE.test(t);
+    const scrub = (list) => list.map(scrubTestVocabulary);
+    const strictBefore = groundedCoverage(scrubbed, scrub(titles), isCrossScrubbed);
+    const strictAfterAll = groundedCoverage(scrubbed, scrub(kept), isCrossScrubbed);
+    const strictAfterTest = groundedCoverage(scrubbed, scrub(kept.filter(testish)), isCrossScrubbed);
+    const plainBefore = groundedCoverage(quotes, titles, isCrossCutting);
+    const plainAfter = groundedCoverage(quotes, kept, isCrossCutting);
+    const out = [];
+    for (let i = 0; i < quotes.length; i++) {
+        const owner = testish(quotes[i]) ? strictAfterTest : strictAfterAll;
+        const strictLost = strictBefore.has(i) && !owner.has(i);
+        const plainLost = plainBefore.has(i) && !plainAfter.has(i);
+        if (strictLost || plainLost)
+            out.push(i);
+    }
+    return out;
+}
+/** How many orphaned requirement quotes the sweep title names, and how long each
+ *  may be — a title is a one-line handoff, not a ledger. */
+const MAX_SWEEP_QUOTES = 6;
+const MAX_QUOTE_CHARS = 120;
+function shorten(q) {
+    const s = q.replace(/\s+/g, ' ').trim();
+    return s.length <= MAX_QUOTE_CHARS ? s : s.slice(0, MAX_QUOTE_CHARS - 1).trimEnd() + '…';
+}
+/**
+ * The scoped replacement: a gap-filling sweep, bounded by what the coverage
+ * source reports and by the requirements that lost their only owner. It states
+ * the ban explicitly, because the child that receives this title sees nothing
+ * else.
+ */
+export function buildSweepTitle(orphaned, coverageSource) {
+    const named = orphaned.slice(0, MAX_SWEEP_QUOTES).map(q => `"${shorten(q)}"`);
+    const more = orphaned.length > named.length ? ` (+${orphaned.length - named.length} more)` : '';
+    return (`Fill the test-coverage gaps left by the per-change tests — run \`${coverageSource}\`,`
+        + ' and add tests ONLY for what it reports uncovered, specifically:'
+        + ` ${named.join('; ')}${more}.`
+        + ' Do NOT re-test what earlier tasks already covered, and do NOT modify'
+        + ' existing test config or existing tests.');
+}
+/**
+ * Rewrite a decomposed plan so it carries no whole-project batch test task when
+ * the decisions mandate tests-in-the-same-change.
+ *
+ * No mandate, or no batch title ⇒ the plan is returned untouched (identity), so
+ * every non-cadence run behaves exactly as before.
+ *
+ * With a mandate, ALL batch titles are removed at once before coverage is
+ * re-measured — otherwise two batch tasks would each mask the other's orphans and
+ * both would look droppable. The orphaned set is then whatever grounded coverage
+ * the removal costs; it is non-empty only when no other task's title claims that
+ * requirement, and it becomes the sweep's scope. At most ONE sweep is emitted (in
+ * the first batch title's position, so plan order is preserved).
+ */
+export function rewriteBatchTestPlan(titles, decisions, spec, requirementQuotes, isCrossCutting) {
+    if (!mandatesTestsInSameChange(decisions, spec))
+        return { titles, actions: [] };
+    const batch = findBatchTestTitles(titles);
+    if (batch.length === 0)
+        return { titles, actions: [] };
+    const batchSet = new Set(batch);
+    const kept = titles.filter((_, i) => !batchSet.has(i));
+    const orphaned = orphanedRequirements(requirementQuotes, titles, kept, isCrossCutting).map(i => requirementQuotes[i]);
+    const actions = [];
+    const out = [];
+    let sweepEmitted = false;
+    for (let i = 0; i < titles.length; i++) {
+        if (!batchSet.has(i)) {
+            out.push(titles[i]);
+            continue;
+        }
+        if (orphaned.length === 0 || sweepEmitted) {
+            actions.push({ index: i, title: titles[i], kind: 'dropped', orphaned: [] });
+            continue;
+        }
+        // Carry the offending title's own [decisions: …] clauses onto the sweep —
+        // they are user directives and survive the reshaping of the task.
+        const { tail } = splitDecisions(titles[i]);
+        const replacement = buildSweepTitle(orphaned, coverageSourceFromSpec(spec)) + tail;
+        actions.push({ index: i, title: titles[i], kind: 'scoped', replacement, orphaned });
+        out.push(replacement);
+        sweepEmitted = true;
+    }
+    return { titles: out, actions };
+}
+/**
+ * The decompose-prompt rule (the belt; the host rewrite above is the lever).
+ * Emitted ONLY when the decisions mandate the cadence, so ordinary runs see the
+ * prompt they always saw. Kept next to the detector so the two cannot drift.
+ */
+export const DECOMPOSE_NO_BATCH_TESTS_RULE = '- The CLARIFICATIONS mandate that tests land in the SAME change as the code they'
+    + ' cover. So do NOT emit a task whose job is writing tests for all components /'
+    + ' all routes / the whole project — that shape is rejected host-side. Fold each'
+    + " test into the task that builds the thing it tests (name it in that task's"
+    + ' title), and emit a separate testing task ONLY as a narrowly scoped sweep of'
+    + ' gaps a coverage run reports. Test INFRASTRUCTURE (runner, config, fixtures)'
+    + ' may still be its own early task.';

package/package.json

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