@mjasnikovs/pi-task 0.18.39 → 0.18.41

package/dist/task/accept-debt.d.ts

@@ -29,8 +29,16 @@
  *     `lsof` and the sandbox had neither) and no further attempt can move it. The
  *     run is allowed to converge on the REMAINING checks, carrying this one here
  *     so the next run's gate re-checks and re-surfaces it rather than losing it.
+ *   - 'root-cause' — the task's verify FAILed because of a PRE-EXISTING defect in a
+ *     file a DIFFERENT task created, which this task's own work never touched (mx5
+ *     run 14: TASK_0007's `test/teardown.ts` TRUNCATE bug FAILed TASK_0013 and
+ *     TASK_0019). The current task is not at fault, so its work — and, at the
+ *     enforce site, the enforce pass's edits — are KEPT rather than reverted; the
+ *     defect is recorded here and a scoped repair task is queued into the plan
+ *     (root-cause-repair.ts). Before this class existed the ledger recorded the same
+ *     root cause twice and nothing ever scheduled a fix, so it survived ~24h.
  */
-export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion' | 'yolo-accepted' | 'final-gate';
+export type DebtOrigin = 'accepted' | 'enforce-revert' | 'frozen-blocked' | 'cross-task-deletion' | 'yolo-accepted' | 'final-gate' | 'root-cause';
 /** One recorded defect: the task, why its VERIFY failed, and how it was recorded. */
 export interface AcceptDebt {
     taskId: string;
@@ -105,6 +113,15 @@ export declare function recordYoloAcceptDebt(cwd: string, taskId: string, reason
  * The taskId is the run's parent id — the demotion is a run-level decision.
  */
 export declare function recordFinalGateUnobservedDebt(cwd: string, taskId: string, reason: string): Promise<void>;
+/**
+ * Record a ROOT-CAUSE debt (mx5 run 14 / PROMPT item 5): this task's verify FAILed
+ * on a pre-existing defect in a file ANOTHER task created and this task never
+ * touched. The current task is not at fault — its work (and, at the enforce site,
+ * the enforce pass's edits) is KEPT — but the defect is real and still in the tree,
+ * so it is recorded here and a scoped repair task is queued (root-cause-repair.ts).
+ * Behavioral/model-judged, so the final gate surfaces it rather than auto-closing it.
+ */
+export declare function recordRootCauseDebt(cwd: string, taskId: string, reason: string): Promise<void>;
 /**
  * The deleted path a cross-task-deletion debt names (the fixed shape
  * recordCrossTaskDeletionDebt writes). Null on any other reason text — an

package/dist/task/accept-debt.js

@@ -78,7 +78,8 @@ export function parseAcceptDebts(raw) {
                 || origin === 'frozen-blocked'
                 || origin === 'cross-task-deletion'
                 || origin === 'yolo-accepted'
-                || origin === 'final-gate') ?
+                || origin === 'final-gate'
+                || origin === 'root-cause') ?
                 { origin: origin }
                 : {})
         });
@@ -203,6 +204,21 @@ export async function recordFinalGateUnobservedDebt(cwd, taskId, reason) {
         origin: 'final-gate'
     });
 }
+/**
+ * Record a ROOT-CAUSE debt (mx5 run 14 / PROMPT item 5): this task's verify FAILed
+ * on a pre-existing defect in a file ANOTHER task created and this task never
+ * touched. The current task is not at fault — its work (and, at the enforce site,
+ * the enforce pass's edits) is KEPT — but the defect is real and still in the tree,
+ * so it is recorded here and a scoped repair task is queued (root-cause-repair.ts).
+ * Behavioral/model-judged, so the final gate surfaces it rather than auto-closing it.
+ */
+export async function recordRootCauseDebt(cwd, taskId, reason) {
+    await appendDebt(cwd, {
+        taskId: taskId.trim(),
+        reason: normaliseReason(reason),
+        origin: 'root-cause'
+    });
+}
 /**
  * The deleted path a cross-task-deletion debt names (the fixed shape
  * recordCrossTaskDeletionDebt writes). Null on any other reason text — an
@@ -357,6 +373,9 @@ export function describeDebt(d) {
     if (d.origin === 'yolo-accepted') {
         return 'auto-ACCEPTED by YOLO mode despite verify-FAIL (unattended — no human weighed this)';
     }
+    if (d.origin === 'root-cause') {
+        return "verify FAILed on a PRE-EXISTING defect in another task's file that this task never touched (this task's work was kept; a scoped repair task was queued for the root cause)";
+    }
     if (d.origin === 'final-gate') {
         return 'final-gate check DEMOTED to UNOBSERVED (identical failure across two tree-changing fix attempts — unfalsifiable in that environment, never proven passing)';
     }

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

@@ -42,5 +42,21 @@ export declare function checkOffTask(cwd: string, id: string, index: number, pro
  * of starting a brand-new task — matching how /task-resume behaves.
  */
 export declare function stampTaskInProgress(cwd: string, id: string, index: number, producedId: string, title: string): Promise<void>;
+/**
+ * Insert a NEW unchecked entry directly after the `afterIndex`th checkbox — the
+ * mid-run plan mutation the root-cause repair channel needs (mx5 run 14 item 5:
+ * a repair task must land BEFORE the next dependent task, not at the end of the
+ * plan, or the defect keeps failing everything in between).
+ *
+ * MONOTONIC by construction (the run-12 replacement lesson): this only ever
+ * SPLICES a line in. No existing entry is rewritten, reordered, or dropped, and
+ * an already-present title is a no-op — so a plan can grow mid-run but never
+ * shrink, and a retried insert cannot duplicate. Returns whether a line was added.
+ *
+ * Later entries shift down by one, which is safe because the /task-auto loop
+ * re-reads and re-parses the plan at the top of every iteration and locates its
+ * next step by "first unchecked" rather than by a cached index.
+ */
+export declare function insertTaskAfter(cwd: string, id: string, afterIndex: number, title: string): Promise<boolean>;
 /** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
 export declare function findResumableAuto(cwd: string): Promise<string | null>;

package/dist/task/auto-io.js

@@ -140,6 +140,60 @@ export async function checkOffTask(cwd, id, index, producedId, title) {
 export async function stampTaskInProgress(cwd, id, index, producedId, title) {
     await rewriteTaskLine(cwd, id, index, () => `- [ ] ${producedId}  ${title}`, 'stampTaskInProgress');
 }
+/** The bare title of a checkbox line (id stamp stripped), or null if not one. */
+function entryTitle(line) {
+    const m = CHECKBOX_RE.exec(line.trim());
+    if (!m)
+        return null;
+    const rest = m[2].trim();
+    const idm = PRODUCED_ID_RE.exec(rest);
+    return idm ? idm[2].trim() : rest;
+}
+/**
+ * Insert a NEW unchecked entry directly after the `afterIndex`th checkbox — the
+ * mid-run plan mutation the root-cause repair channel needs (mx5 run 14 item 5:
+ * a repair task must land BEFORE the next dependent task, not at the end of the
+ * plan, or the defect keeps failing everything in between).
+ *
+ * MONOTONIC by construction (the run-12 replacement lesson): this only ever
+ * SPLICES a line in. No existing entry is rewritten, reordered, or dropped, and
+ * an already-present title is a no-op — so a plan can grow mid-run but never
+ * shrink, and a retried insert cannot duplicate. Returns whether a line was added.
+ *
+ * Later entries shift down by one, which is safe because the /task-auto loop
+ * re-reads and re-parses the plan at the top of every iteration and locates its
+ * next step by "first unchecked" rather than by a cached index.
+ */
+export async function insertTaskAfter(cwd, id, afterIndex, title) {
+    const clean = title.trim();
+    if (clean.length === 0)
+        return false;
+    const { body } = await readTaskFile(cwd, id);
+    const section = extractSection(body, 'tasks') ?? '';
+    const lines = section.split('\n');
+    // Duplicate check scans the WHOLE list first: an existing entry with this exact
+    // title (checked or not) means the plan already carries this step, wherever it
+    // sits relative to afterIndex — never add a second one.
+    if (lines.some(l => entryTitle(l) === clean))
+        return false;
+    let seen = -1;
+    let insertAt = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (!CHECKBOX_RE.test(lines[i].trim()))
+            continue;
+        seen++;
+        insertAt = i + 1;
+        if (seen === afterIndex)
+            break;
+    }
+    // An out-of-range index appends after the LAST checkbox rather than throwing:
+    // a plan that grew underneath the caller must still receive the entry.
+    if (insertAt === -1)
+        return false;
+    lines.splice(insertAt, 0, `- [ ] ${clean}`);
+    await setTaskSection(cwd, id, 'tasks', lines.join('\n'));
+    return true;
+}
 /** Find the most-recently-updated resumable TASK_AUTO_* file, or null. */
 export async function findResumableAuto(cwd) {
     await ensureTasksDir(cwd);

package/dist/task/auto-orchestrator.js

@@ -14,7 +14,8 @@ import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.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, parseCoverageVerdict, parseTaskList, checkOffTask, stampTaskInProgress, findResumableAuto } from './auto-io.js';
+import { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, parseTaskList, checkOffTask, stampTaskInProgress, insertTaskAfter, findResumableAuto } from './auto-io.js';
+import { drainRepairQueue, mergeRepairCandidates, planHasRepairFor, parseRepairTitleFile, buildRepairTitle, buildRepairScopeFence, extractFailingCommand } from './root-cause-repair.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';
@@ -38,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';
@@ -320,6 +322,63 @@ export function buildScopeFence(titles, currentIndex) {
         + `components, or flows owned by a later step.\n\n`
         + `The full plan (these run separately — do NOT implement them here):\n${listing}`);
 }
+/**
+ * The scope fence for step `currentIndex`, plus the REPAIR fence when that step is
+ * a queued root-cause repair. A repair title ("repair test/teardown.ts: …") reads
+ * to refine like any other feature step, and refine's job is to expand a title into
+ * a full spec — which is exactly how "repair the teardown" becomes "overhaul the
+ * test infrastructure" (the /task-auto drift lesson). The extra fence pins the one
+ * editable file and pins VERIFY to the command the defect was failing.
+ */
+function buildStepFence(titles, currentIndex) {
+    const base = buildScopeFence(titles, currentIndex);
+    const repairFile = parseRepairTitleFile(titles[currentIndex] ?? '');
+    if (!repairFile)
+        return base;
+    return `${base}\n\n${buildRepairScopeFence(repairFile, extractFailingCommand(titles[currentIndex] ?? ''))}`;
+}
+/**
+ * Drain the gate's root-cause repair queue into the running plan: one scoped
+ * repair step per accused FILE, spliced in directly after the step that just
+ * finished.
+ *
+ * Three bounds, all mandatory (mx5 run 14 item 5 gray areas):
+ *   - DEDUP by file — run 14's two `test/teardown.ts` debts must yield ONE repair
+ *     step, not two. mergeRepairCandidates collapses the drained queue, and
+ *     planHasRepairFor rejects a file the plan already carries a repair for.
+ *   - CAP 1 per file per RUN — planHasRepairFor counts CHECKED-OFF entries too, so
+ *     a repair step that itself failed is never re-spawned; it lands in the
+ *     accept-debt ledger like any other task. That is what stops a repair loop.
+ *   - MONOTONIC — insertTaskAfter only splices; no existing entry is rewritten,
+ *     reordered or dropped (the run-12 replacement lesson).
+ *
+ * Best-effort throughout: a fault here must never fail the run that produced the
+ * finding — the debt is already durably recorded either way.
+ */
+async function schedulePendingRepairs(cwd, id, afterIndex, ctx, deps) {
+    try {
+        const pending = await drainRepairQueue(cwd);
+        if (pending.length === 0)
+            return;
+        const { body } = await readTaskFile(cwd, id);
+        const titles = parseTaskList(body).map(e => e.title);
+        let at = afterIndex;
+        for (const repair of mergeRepairCandidates(pending)) {
+            if (planHasRepairFor(titles, repair.file))
+                continue;
+            const title = buildRepairTitle(repair);
+            if (!(await insertTaskAfter(cwd, id, at, title)))
+                continue;
+            titles.splice(at + 1, 0, title);
+            at += 1;
+            await deps.record?.(cwd, id, `plan: inserted scoped repair step after step ${afterIndex + 1} — ${title}`);
+            ctx.ui.notify(`${id}: queued a scoped repair for ${repair.file} (${repair.owner}'s file — root cause of ${repair.blamed.join(', ')}).`, 'warning');
+        }
+    }
+    catch {
+        // the plan is best-effort here; the underlying debt is already recorded
+    }
+}
 /** Plan phase: clarify → decompose → write AUTO file. Returns the new id, or null. */
 export async function planAuto(ctx, cwd, feature, deps) {
     // clarify — sequential & adaptive: ask one question at a time, feeding every
@@ -532,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
@@ -548,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);
@@ -1341,7 +1421,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 // matters when refine runs fresh (a resumed task past refine ignores
                 // it), but always supplied so a resume that restarts at refine is
                 // fenced too.
-                planContext: buildScopeFence(entries.map(e => e.title), next.index),
+                planContext: buildStepFence(entries.map(e => e.title), next.index),
                 onStart: resumeId ? undefined : (innerId => stampTaskInProgress(cwd, id, next.index, innerId, next.title))
             });
             active = res.ctx ?? active;
@@ -1396,7 +1476,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 title: next.title,
                 tag: id,
                 // Fence an AUTOFIX re-run against re-expanding the whole spec.
-                planContext: buildScopeFence(entries.map(e => e.title), next.index),
+                planContext: buildStepFence(entries.map(e => e.title), next.index),
                 // res.ok === true means runner.run() completed, so res.taskId is the
                 // allocated TASK_NNNN id (never empty here). The parent task-list
                 // check-off runs after verify passes/accepts and before the commit,
@@ -1426,6 +1506,14 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 announceDone(active, `${id} stopped at "${next.title}"${why} — fix and run /task-auto-resume.`, 'error');
                 return;
             }
+            // ROOT-CAUSE REPAIR (mx5 run 14 item 5): the gate may have attributed a
+            // FAIL to a pre-existing defect in a file some OTHER task created. It can
+            // only QUEUE that finding — mutating the plan is this loop's job. Drain
+            // the queue and splice a scoped repair step in right after the step that
+            // just finished, so the defect is fixed BEFORE the next dependent task
+            // trips over it too (run 14 recorded the same `test/teardown.ts` cause
+            // twice, scheduled nothing, and the bug outlived ~24h of the run).
+            await schedulePendingRepairs(cwd, id, next.index, active, deps);
             // gate.kind === 'done' → fall through to the next task, after checking
             // no landmine stash was left behind by anything that ran in between.
             if (deps.stashRef && stashBefore !== undefined) {

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;