@mjasnikovs/pi-task 0.18.39 → 0.18.40

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';
@@ -320,6 +321,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
@@ -1341,7 +1399,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 +1454,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 +1484,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/gate-deps.js

@@ -22,7 +22,8 @@ import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
 import { readEnvNotes, appendEnvNotes } from './env-notes.js';
 import { readContracts } from './contracts.js';
-import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt, recordYoloAcceptDebt } from './accept-debt.js';
+import { recordAcceptDebt, recordEnforceRevertDebt, recordFrozenBlockedDebt, recordCrossTaskDeletionDebt, recordYoloAcceptDebt, recordRootCauseDebt } from './accept-debt.js';
+import { recordRepairCandidate } from './root-cause-repair.js';
 import { runRepoHealthCheck } from './repo-health-check.js';
 import { runFinalIntegrationGate, discoverGateCommandLabels } from './final-gate.js';
 import { runFinalGateAutofix } from './final-gate-fix.js';
@@ -471,6 +472,40 @@ export function buildGateDeps(params) {
         // deliverable this task's diff deletes, ACCEPTed into a commit anyway —
         // the final gate re-checks it (resolved iff the file is back in the tree).
         recordCrossTaskDeletionDebt: (cwd2, taskId, deletion) => recordCrossTaskDeletionDebt(cwd2, taskId, deletion),
+        // ROOT-CAUSE channel (mx5 run 14 item 5): a FAIL another task's untouched
+        // file caused is recorded as its own debt class and queued as a scoped
+        // repair task, instead of being blamed on — and reverted out of — the task
+        // that merely tripped over it.
+        recordRootCauseDebt: (cwd2, taskId, reason) => recordRootCauseDebt(cwd2, taskId, reason),
+        recordRepairCandidate: (cwd2, candidate) => recordRepairCandidate(cwd2, candidate),
+        // file → introducing task, the provenance half of the discriminator.
+        introducedBy: (cwd2, rel) => Promise.resolve(taskThatIntroduced(cwd2, rel)),
+        // The authorship half: which files THIS task's work touched. `worktree` is
+        // the pre-commit verify site (uncommitted changes); `committed` is the
+        // post-commit enforce site, where the task snapshot and the ENFORCE commit
+        // are the last two commits. Any git fault returns null, which stands the
+        // channel down entirely rather than guessing.
+        touchedFiles: async (cwd2, scope) => {
+            try {
+                if (scope === 'worktree') {
+                    const r = await git(cwd2, ['status', '--porcelain'], signal);
+                    if (r.exitCode !== 0)
+                        return null;
+                    const c = parseTreeChanges(r.stdout);
+                    return [...c.modified, ...c.added, ...c.deleted];
+                }
+                const r = await git(cwd2, ['log', '-n', '2', '--name-only', '--format=', 'HEAD'], signal);
+                if (r.exitCode !== 0)
+                    return null;
+                return r.stdout
+                    .split('\n')
+                    .map(l => l.trim())
+                    .filter(l => l.length > 0);
+            }
+            catch {
+                return null;
+            }
+        },
         // Frozen-path write-deny (see frozen-path-guard.ts): the concrete paths this
         // task's spec forbids modifying, so the gate sequence can UNDO any edit the
         // enforce EDIT pass makes to them before those edits are committed. Reads the

package/dist/task/root-cause-repair.d.ts

@@ -0,0 +1,122 @@
+/** One file accused of causing another task's verify FAIL. */
+export interface RepairCandidate {
+    /** Repo-relative path of the accused file. */
+    file: string;
+    /** The task whose commit introduced `file` (provenance). */
+    owner: string;
+    /** One-line summary of the defect, lifted from the FAIL text. */
+    defect: string;
+    /** The task whose verify FAILed because of it. */
+    blamedTask: string;
+    /** The failing command from the debt — becomes the repair task's VERIFY. */
+    verifyCommand?: string;
+}
+/** True when the FAIL text blames the ENVIRONMENT rather than a file. */
+export declare function isEnvironmentAttributed(text: string): boolean;
+interface Accusation {
+    file: string;
+    /** Character distance between the blame cue and the path token. */
+    distance: number;
+    /** The clause the accusation was made in — the defect summary source. */
+    clause: string;
+}
+/**
+ * The single file a FAIL text accuses, or null. Scans every blame cue, pairs it
+ * with the NEAREST path token within {@link BLAME_WINDOW} characters (a cue and its
+ * subject sit adjacent in practice: "pre-existing teardown bug in
+ * `test/teardown.ts`"), and keeps the closest pair overall. One FAIL has one root
+ * cause, so this deliberately returns at most one accusation rather than every
+ * path the reason happens to name.
+ */
+export declare function findAccusedFile(text: string): Accusation | null;
+/**
+ * Collapse whitespace and clamp — a stored defect summary is one short line that
+ * has to read well inside a plan title. The gate's own verdict boilerplate ("work
+ * did not verify: ") and a leading repeat of the accused file are stripped: the
+ * title already names both the step kind and the file, so repeating them there
+ * spends the clamp budget on nothing.
+ */
+export declare function summariseDefect(clause: string, file?: string): string;
+/**
+ * A runnable command quoted in the FAIL text — the repair task's VERIFY, per the
+ * requirement that it re-run the exact command the debt failed on. Only the first
+ * backticked token that STARTS like a shell command (optionally env-prefixed)
+ * qualifies, so prose in backticks is never mistaken for a command.
+ */
+export declare function extractFailingCommand(text: string): string | undefined;
+export interface RootCauseInput {
+    /** The verify gate's FAIL reason. */
+    failReason: string;
+    /** The resolution research's rationale, when one ran ('' otherwise). */
+    rationale?: string;
+    /** The task whose verify FAILed. */
+    currentTaskId: string;
+    /**
+     * Paths the CURRENT task's own work touches. `null` means unknown (git
+     * unavailable) — the channel stands down rather than guessing, so an
+     * unreadable tree can only cost a repair task, never spawn a wrong one.
+     */
+    touched: string[] | null;
+    /** file → introducing task (task-provenance.ts). May throw; a throw reads
+     *  as unknown provenance. */
+    introducedBy: (rel: string) => string | null | Promise<string | null>;
+}
+/**
+ * The repair candidate a verify FAIL justifies, or null. All three conditions from
+ * the module header must hold; anything unknown or environment-shaped returns null.
+ */
+export declare function findRepairCandidate(input: RootCauseInput): Promise<RepairCandidate | null>;
+export declare function repairQueueFile(cwd: string): string;
+/** Parse the stored queue. Malformed lines are skipped, never thrown on. */
+export declare function parseRepairQueue(raw: string): RepairCandidate[];
+/** Append one candidate. Best-effort — the queue never blocks a gate. */
+export declare function recordRepairCandidate(cwd: string, c: RepairCandidate): Promise<void>;
+/**
+ * Read the queue and CLEAR it. Draining is what makes the "cap 1 repair task per
+ * file per run" bound hold without a second ledger: whatever is drained either
+ * becomes a plan entry (which is then itself the dedup key — see
+ * {@link planHasRepairFor}) or was already covered by one.
+ */
+export declare function drainRepairQueue(cwd: string): Promise<RepairCandidate[]>;
+/** One merged repair per file, carrying every task the defect FAILed. */
+export interface MergedRepair {
+    file: string;
+    owner: string;
+    defect: string;
+    blamed: string[];
+    verifyCommand?: string;
+}
+/**
+ * Collapse candidates by file — MANDATORY dedup: run 14's two teardown.ts debts
+ * (TASK_0013, TASK_0019) must yield exactly ONE repair task naming both. First
+ * record wins for defect/command (they describe the same fault); blamed tasks
+ * accumulate in first-seen order.
+ */
+export declare function mergeRepairCandidates(candidates: RepairCandidate[]): MergedRepair[];
+/** Machine-recognisable prefix, so a repair entry can be found in a plan again. */
+export declare const REPAIR_TITLE_PREFIX = "repair ";
+/**
+ * The plan title for a repair task, in the fixed shape
+ * `repair <file>: <defect> (root cause of TASK_A, TASK_B debts)`. The file sits
+ * immediately after the prefix so {@link parseRepairTitleFile} can recover it —
+ * that recovery is both the dedup key and how the loop knows to attach the
+ * repair scope fence.
+ */
+export declare function buildRepairTitle(r: MergedRepair): string;
+/** The file a repair title names, or null when the title is not a repair entry. */
+export declare function parseRepairTitleFile(title: string): string | null;
+/**
+ * Is a repair for `file` ALREADY in the plan? This is the cap-1-per-file-per-run
+ * bound: it counts checked-off entries too, so a repair task that ran and FAILed
+ * is never re-spawned — it lands in the accept-debt ledger like any other task.
+ */
+export declare function planHasRepairFor(titles: string[], file: string): boolean;
+/**
+ * The extra scope fence a repair entry carries into refine. Without it, refine
+ * re-expands "repair test/teardown.ts: parameterized table names in TRUNCATE"
+ * into "overhaul the test infrastructure" — the /task-auto drift lesson. The
+ * fence pins the single editable file and pins the VERIFY to the exact command
+ * the debt failed on.
+ */
+export declare function buildRepairScopeFence(file: string, verifyCommand?: string): string;
+export {};

package/dist/task/root-cause-repair.js

@@ -0,0 +1,378 @@
+/**
+ * root-cause-repair — turn a verify-FAIL that was CAUSED by another task's file
+ * into a scoped repair task in the running plan (mx5 run 14, PROMPT item 5).
+ *
+ * The failure class this closes, observed end-to-end in run 14: TASK_0007 shipped
+ * `test/teardown.ts` with parameterized table names in its TRUNCATE statements.
+ * That bug then FAILED two later, unrelated tasks —
+ *
+ *   TASK_0013  "test/teardown.ts has a pre-existing bug (parameterized table names
+ *               in TRUNCATE statements) … despite all 10 actual tests passing"
+ *   TASK_0019  "… due to a pre-existing teardown bug in `test/teardown.ts`
+ *               (created by TASK_0007) … this task did not modify the teardown"
+ *
+ * — and BOTH ended in an enforce-revert, so the enforce pass's edits were destroyed
+ * over a defect the current task did not create. The ledger recorded the root cause
+ * twice and NOTHING ever scheduled a fix: the bug survived ~24h, until the final
+ * gate's fix child happened to patch it, and it also generated the "2 pre-existing
+ * failures / state pollution" excuse notes repeated across TASK_0033…0038.
+ *
+ * The channel here is deliberately narrow, because a false positive costs a whole
+ * task slot and mutates a running plan. Three independent conditions must ALL hold:
+ *
+ *   1. TEXT — the FAIL reason (or the resolution research's rationale) carries an
+ *      explicit blame cue ("pre-existing", "created by TASK_nnnn", "bug in", "this
+ *      task did not modify") and a path token near it. Merely MENTIONING a path is
+ *      not blame: run 14's TASK_0010 FAIL lists `src/server/db.ts` inside the
+ *      spec's own "Preserve all existing files on disk" quote, and must not spawn
+ *      a repair task for it.
+ *   2. PROVENANCE — the blamed file was introduced by a DIFFERENT task's commit
+ *      (task-provenance.ts). Unknown provenance is never evidence.
+ *   3. AUTHORSHIP — the current task's own work does not touch the blamed file. If
+ *      this task edited it, the defect may well be its own and the ordinary
+ *      autofix/revert path is right.
+ *
+ * Environment-attributed failures are vetoed outright (run 14's TASK_0006: "no
+ * PostgreSQL database server is available in this environment"). No file edit can
+ * repair a missing daemon, so a repair task would be a guaranteed non-converging
+ * yolo-FAIL.
+ *
+ * Everything downstream is deduplicated by FILE: N debts naming one root file yield
+ * exactly ONE repair task per run (run 14 would otherwise have spawned two for
+ * `test/teardown.ts`). The repair task itself is just an ordinary plan entry — if it
+ * fails, it lands in the ledger like any other task and is never re-spawned, which
+ * is what keeps this from looping.
+ */
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { tasksDir } from './task-io.js';
+/** A path-like token: at least one directory separator, ending in a file name. */
+const PATH_TOKEN_RE = /(?:[\w.@-]+\/)+[\w.@-]+\.\w+/g;
+/**
+ * Phrases that ATTRIBUTE a failure to something that predates the current task.
+ * Each is a blame cue: the path token nearest a cue is the accused file. Kept
+ * deliberately specific — a bare "existing" matches the spec boilerplate
+ * "Preserve all existing files on disk" that run 14's TASK_0010 FAIL quotes.
+ */
+const BLAME_CUE_RE = /pre-?\s?existing|existing (?:bug|defect|failure|issue|fault)|(?:created|introduced|added|written) (?:by|in) TASK_\d+|(?:bug|defect|fault|error) in\b|already (?:broken|failing|red)|(?:this task )?did not (?:modify|touch|create|change)|not (?:modified|touched|created|introduced) by this task|unrelated to this task/gi;
+/**
+ * Failures the environment causes, not a file. No edit to any file repairs a
+ * missing database server, so these must never open the repair channel — run 14's
+ * TASK_0006 ("no PostgreSQL database server is available in this environment (no
+ * binary, no Docker, no listener on port 5432)") is the canonical shape.
+ */
+const ENVIRONMENT_BLAME_RE = /no (?:postgres|postgresql|mysql|database|redis|docker|network|internet|display)\b|not (?:installed|available|running|present) (?:in|on|for) (?:this |the )?(?:env|environment|sandbox|container|machine|image|system)|(?:environment|env|sandbox|container) (?:gap|limitation|lacks|has no|does not (?:have|provide))|no (?:binary|listener|daemon|server) (?:on|for|available)|missing (?:binary|executable|system (?:tool|package)|runtime)|is not installed|command not found/i;
+/** How far from a blame cue a path token may sit and still be the accused file. */
+const BLAME_WINDOW = 160;
+/** A recorded defect summary is one clamped line, not prose. */
+const MAX_DEFECT_LENGTH = 160;
+/** Ledger ceiling — a pathological run cannot grow the queue unboundedly. */
+const MAX_QUEUED = 40;
+const REPAIR_QUEUE_FILE = 'repair-queue.md';
+const FIELD_SEP = '\t';
+/** True when the FAIL text blames the ENVIRONMENT rather than a file. */
+export function isEnvironmentAttributed(text) {
+    return ENVIRONMENT_BLAME_RE.test(text);
+}
+/**
+ * The single file a FAIL text accuses, or null. Scans every blame cue, pairs it
+ * with the NEAREST path token within {@link BLAME_WINDOW} characters (a cue and its
+ * subject sit adjacent in practice: "pre-existing teardown bug in
+ * `test/teardown.ts`"), and keeps the closest pair overall. One FAIL has one root
+ * cause, so this deliberately returns at most one accusation rather than every
+ * path the reason happens to name.
+ */
+export function findAccusedFile(text) {
+    if (text.trim().length === 0)
+        return null;
+    const paths = [...text.matchAll(PATH_TOKEN_RE)].map(m => ({
+        value: m[0],
+        start: m.index,
+        end: m.index + m[0].length
+    }));
+    if (paths.length === 0)
+        return null;
+    let best = null;
+    // matchAll on a /g regex is safe here (fresh iterator, no shared lastIndex).
+    for (const cue of text.matchAll(BLAME_CUE_RE)) {
+        const cueStart = cue.index;
+        const cueEnd = cueStart + cue[0].length;
+        for (const p of paths) {
+            const distance = p.start >= cueEnd ? p.start - cueEnd
+                : p.end <= cueStart ? cueStart - p.end
+                    : 0;
+            if (distance > BLAME_WINDOW)
+                continue;
+            if (best === null || distance < best.distance) {
+                best = { file: p.value, distance, clause: clauseAround(text, cueStart) };
+            }
+        }
+    }
+    return best;
+}
+/**
+ * The sentence/clause a character offset sits in. Splitting on sentence and dash
+ * boundaries keeps the defect summary to the accusation itself instead of the
+ * whole multi-clause FAIL reason.
+ */
+function clauseAround(text, offset) {
+    const before = text.slice(0, offset);
+    const startMatch = /[.;]\s|\s—\s/g;
+    let start = 0;
+    for (const m of before.matchAll(startMatch))
+        start = m.index + m[0].length;
+    const after = text.slice(offset);
+    const endMatch = /[.;]\s|\s—\s/.exec(after);
+    const end = endMatch ? offset + endMatch.index : text.length;
+    return text.slice(start, end).trim();
+}
+/**
+ * Collapse whitespace and clamp — a stored defect summary is one short line that
+ * has to read well inside a plan title. The gate's own verdict boilerplate ("work
+ * did not verify: ") and a leading repeat of the accused file are stripped: the
+ * title already names both the step kind and the file, so repeating them there
+ * spends the clamp budget on nothing.
+ */
+export function summariseDefect(clause, file) {
+    let out = clause.replace(/\s+/g, ' ').trim();
+    out = out.replace(/^work (?:did not verify|unobserved|is unverified)\s*:\s*/i, '');
+    if (file) {
+        const escaped = file.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        out = out.replace(new RegExp(`^\`?${escaped}\`?\\s+(?:has|had|contains)\\s+an?\\s+`, 'i'), '');
+    }
+    out = out.replace(/^[,\-—:\s]+/, '').trim();
+    // Drop trailing consequence clauses — "X is broken, which means the VERIFY
+    // command fails" restates the FAIL; the repair task only needs the X.
+    out = out.replace(/,\s*(?:which|so|meaning|causing the VERIFY)\b.*$/i, '');
+    if (out.length <= MAX_DEFECT_LENGTH)
+        return out;
+    const cut = out.slice(0, MAX_DEFECT_LENGTH);
+    const lastSpace = cut.lastIndexOf(' ');
+    return `${(lastSpace > MAX_DEFECT_LENGTH / 2 ? cut.slice(0, lastSpace) : cut).trimEnd()}…`;
+}
+/**
+ * A runnable command quoted in the FAIL text — the repair task's VERIFY, per the
+ * requirement that it re-run the exact command the debt failed on. Only the first
+ * backticked token that STARTS like a shell command (optionally env-prefixed)
+ * qualifies, so prose in backticks is never mistaken for a command.
+ */
+export function extractFailingCommand(text) {
+    const RUNNER = /^(?:[A-Z][A-Z0-9_]*=\S+\s+)*(?:bun|npm|pnpm|yarn|npx|node|deno|make|cargo|go|python3?|pytest|dotnet|mvn|gradle)\b\s+\S/;
+    for (const m of text.matchAll(/`([^`\n]+)`/g)) {
+        const cmd = m[1].trim();
+        if (RUNNER.test(cmd))
+            return cmd;
+    }
+    return undefined;
+}
+/**
+ * The repair candidate a verify FAIL justifies, or null. All three conditions from
+ * the module header must hold; anything unknown or environment-shaped returns null.
+ */
+export async function findRepairCandidate(input) {
+    const current = input.currentTaskId.trim();
+    if (current.length === 0)
+        return null;
+    if (input.touched === null)
+        return null;
+    const text = [input.failReason, input.rationale ?? '']
+        .filter(t => t.trim().length > 0)
+        .join(' ');
+    if (text.trim().length === 0)
+        return null;
+    if (isEnvironmentAttributed(text))
+        return null;
+    const accused = findAccusedFile(text);
+    if (!accused)
+        return null;
+    // AUTHORSHIP: a file this task's own work touches is not somebody else's bug.
+    // Suffix-compare so an absolute or `./`-prefixed status path still matches.
+    const touchedSet = input.touched.map(t => normalisePath(t));
+    const file = normalisePath(accused.file);
+    if (touchedSet.some(t => t === file || t.endsWith(`/${file}`) || file.endsWith(`/${t}`))) {
+        return null;
+    }
+    let owner;
+    try {
+        owner = await input.introducedBy(accused.file);
+    }
+    catch {
+        owner = null;
+    }
+    if (!owner || owner === current)
+        return null;
+    return {
+        file: accused.file,
+        owner,
+        defect: summariseDefect(accused.clause, accused.file),
+        blamedTask: current,
+        ...(extractFailingCommand(text) ? { verifyCommand: extractFailingCommand(text) } : {})
+    };
+}
+function normalisePath(p) {
+    return p.replace(/^\.\//, '').replace(/^\/+/, '').trim();
+}
+// ─── Durable queue ───────────────────────────────────────────────────────────
+//
+// The gate sequence (task-gates.ts) DETECTS candidates; the /task-auto loop is
+// what may mutate the plan. They are decoupled through a small ledger under
+// `.pi-tasks/` — the same durability contract as accept-debt.ts: it survives
+// discardEdits and the git-state guard, and a resume picks up what a crash left.
+export function repairQueueFile(cwd) {
+    return path.join(tasksDir(cwd), REPAIR_QUEUE_FILE);
+}
+function serialize(c) {
+    return [c.file, c.owner, c.blamedTask, c.verifyCommand ?? '', c.defect]
+        .map(f => f.replace(/[\t\n]+/g, ' ').trim())
+        .join(FIELD_SEP);
+}
+/** Parse the stored queue. Malformed lines are skipped, never thrown on. */
+export function parseRepairQueue(raw) {
+    const out = [];
+    for (const line of raw.split('\n')) {
+        const t = line.trim();
+        if (t.length === 0)
+            continue;
+        const parts = t.split(FIELD_SEP);
+        if (parts.length < 5)
+            continue;
+        const [file, owner, blamedTask, verifyCommand, defect] = parts;
+        if (!file.trim() || !owner.trim())
+            continue;
+        out.push({
+            file: file.trim(),
+            owner: owner.trim(),
+            blamedTask: blamedTask.trim(),
+            defect: defect.trim(),
+            ...(verifyCommand.trim() ? { verifyCommand: verifyCommand.trim() } : {})
+        });
+    }
+    return out;
+}
+/** Append one candidate. Best-effort — the queue never blocks a gate. */
+export async function recordRepairCandidate(cwd, c) {
+    try {
+        const existing = parseRepairQueue(await readQueueRaw(cwd));
+        const key = (x) => `${x.file.toLowerCase()} ${x.blamedTask.toLowerCase()}`;
+        if (existing.some(e => key(e) === key(c)))
+            return;
+        const kept = [...existing, c].slice(-MAX_QUEUED);
+        await fsp.mkdir(tasksDir(cwd), { recursive: true });
+        await fsp.writeFile(repairQueueFile(cwd), kept.map(serialize).join('\n') + '\n', 'utf8');
+    }
+    catch {
+        // best-effort ledger
+    }
+}
+async function readQueueRaw(cwd) {
+    try {
+        return (await fsp.readFile(repairQueueFile(cwd), 'utf8')).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Read the queue and CLEAR it. Draining is what makes the "cap 1 repair task per
+ * file per run" bound hold without a second ledger: whatever is drained either
+ * becomes a plan entry (which is then itself the dedup key — see
+ * {@link planHasRepairFor}) or was already covered by one.
+ */
+export async function drainRepairQueue(cwd) {
+    const parsed = parseRepairQueue(await readQueueRaw(cwd));
+    if (parsed.length === 0)
+        return [];
+    try {
+        await fsp.writeFile(repairQueueFile(cwd), '', 'utf8');
+    }
+    catch {
+        // best-effort; a failed clear at worst re-offers candidates that
+        // planHasRepairFor then rejects.
+    }
+    return parsed;
+}
+/**
+ * Collapse candidates by file — MANDATORY dedup: run 14's two teardown.ts debts
+ * (TASK_0013, TASK_0019) must yield exactly ONE repair task naming both. First
+ * record wins for defect/command (they describe the same fault); blamed tasks
+ * accumulate in first-seen order.
+ */
+export function mergeRepairCandidates(candidates) {
+    const byFile = new Map();
+    for (const c of candidates) {
+        const key = normalisePath(c.file).toLowerCase();
+        const prev = byFile.get(key);
+        if (!prev) {
+            byFile.set(key, {
+                file: c.file,
+                owner: c.owner,
+                defect: c.defect,
+                blamed: c.blamedTask ? [c.blamedTask] : [],
+                ...(c.verifyCommand ? { verifyCommand: c.verifyCommand } : {})
+            });
+            continue;
+        }
+        if (c.blamedTask && !prev.blamed.includes(c.blamedTask))
+            prev.blamed.push(c.blamedTask);
+        if (!prev.verifyCommand && c.verifyCommand)
+            prev.verifyCommand = c.verifyCommand;
+    }
+    return [...byFile.values()];
+}
+// ─── Plan entry ──────────────────────────────────────────────────────────────
+/** Machine-recognisable prefix, so a repair entry can be found in a plan again. */
+export const REPAIR_TITLE_PREFIX = 'repair ';
+/**
+ * The plan title for a repair task, in the fixed shape
+ * `repair <file>: <defect> (root cause of TASK_A, TASK_B debts)`. The file sits
+ * immediately after the prefix so {@link parseRepairTitleFile} can recover it —
+ * that recovery is both the dedup key and how the loop knows to attach the
+ * repair scope fence.
+ */
+export function buildRepairTitle(r) {
+    const blame = r.blamed.length > 0 ? ` (root cause of ${r.blamed.join(', ')} debts)` : '';
+    return `${REPAIR_TITLE_PREFIX}${r.file}: ${r.defect}${blame}`;
+}
+/** The file a repair title names, or null when the title is not a repair entry. */
+export function parseRepairTitleFile(title) {
+    const m = /^repair\s+((?:[\w.@-]+\/)*[\w.@-]+\.\w+)\s*:/.exec(title.trim());
+    return m ? m[1] : null;
+}
+/**
+ * Is a repair for `file` ALREADY in the plan? This is the cap-1-per-file-per-run
+ * bound: it counts checked-off entries too, so a repair task that ran and FAILed
+ * is never re-spawned — it lands in the accept-debt ledger like any other task.
+ */
+export function planHasRepairFor(titles, file) {
+    const want = normalisePath(file).toLowerCase();
+    return titles.some(t => {
+        const f = parseRepairTitleFile(t);
+        return f !== null && normalisePath(f).toLowerCase() === want;
+    });
+}
+/**
+ * The extra scope fence a repair entry carries into refine. Without it, refine
+ * re-expands "repair test/teardown.ts: parameterized table names in TRUNCATE"
+ * into "overhaul the test infrastructure" — the /task-auto drift lesson. The
+ * fence pins the single editable file and pins the VERIFY to the exact command
+ * the debt failed on.
+ */
+export function buildRepairScopeFence(file, verifyCommand) {
+    return [
+        `REPAIR TASK — this step exists ONLY to fix one specific pre-existing defect in`,
+        `\`${file}\`. It was created because that file made OTHER tasks' verification fail;`,
+        `it is not a feature step and must not grow into one.`,
+        '',
+        'HARD CONSTRAINTS for this step (they override any broader reading of the title):',
+        `  - \`${file}\` is the ONLY file you may modify. Do not refactor, restructure, or`,
+        '    "improve" anything else, and do not create new files.',
+        '  - Fix the named defect and nothing more. Do NOT redesign the test harness, the',
+        '    build, the schema, or any shared infrastructure — a wider change here would',
+        "    silently overwrite sibling tasks' shipped work.",
+        '  - Do not delete or weaken any existing test to make the command pass.',
+        verifyCommand ?
+            `  - The VERIFY block MUST be exactly: \`${verifyCommand}\` — the command this`
+                + '    defect was failing. It passing is the whole acceptance criterion.'
+            : '  - The VERIFY block MUST re-run the command the defect was failing, unaided.'
+    ].join('\n');
+}

package/dist/task/task-gates.d.ts

@@ -34,6 +34,7 @@ import type { CommitResult } from './auto-commit.js';
 import type { VerifyOutcome } from './verify-work.js';
 import type { EnforceOutcome } from './enforce-guidelines.js';
 import { type ResolutionOutcome, type ResolutionChoice } from './verify-resolution.js';
+import { type RepairCandidate } from './root-cause-repair.js';
 /**
  * The deps the gate sequence drives. A superset of these is built once per command
  * by buildGateDeps; AutoDeps extends this with the planning-only `runChild`. Every
@@ -162,6 +163,36 @@ export interface GateDeps {
         path: string;
         owner: string;
     }) => Promise<void>;
+    /**
+     * Record a durable ROOT-CAUSE debt (mx5 run 14 item 5): this task's verify
+     * FAILed on a pre-existing defect in a file ANOTHER task created and this task
+     * never touched. Its work is kept (it is not at fault) but the defect is real,
+     * so the final gate must re-check and surface it. Best-effort; absent in tests.
+     */
+    recordRootCauseDebt?: (cwd: string, taskId: string, reason: string) => Promise<void>;
+    /**
+     * Queue a scoped repair task for a root-caused defect. The gate DETECTS the
+     * cause; only the /task-auto loop may mutate the plan, so the two are decoupled
+     * through the durable `.pi-tasks/repair-queue.md` ledger this writes (see
+     * root-cause-repair.ts). Absent (bare `/task`, tests) → detection still records
+     * the debt, nothing is scheduled.
+     */
+    recordRepairCandidate?: (cwd: string, candidate: RepairCandidate) => Promise<void>;
+    /**
+     * Paths the CURRENT task's own work touches — the AUTHORSHIP discriminator for
+     * the root-cause channel: a FAIL blamed on a file this task edited may well be
+     * this task's own fault, and only a file it never touched can be somebody
+     * else's pre-existing bug. `worktree` = uncommitted changes (the pre-commit
+     * verify site); `committed` = the files the task snapshot + the ENFORCE commit
+     * changed (the post-commit enforce site). `null` means UNKNOWN (git
+     * unavailable) and stands the whole channel down — inconclusive is never
+     * evidence, so an unreadable tree can only cost a repair task, never spawn a
+     * wrong one or wrongly keep a regression.
+     */
+    touchedFiles?: (cwd: string, scope: 'worktree' | 'committed') => Promise<string[] | null>;
+    /** The task whose commit INTRODUCED a file (task-provenance.ts). Null for a
+     *  file predating the run or any git error → unknown provenance. */
+    introducedBy?: (cwd: string, rel: string) => Promise<string | null>;
     /**
      * The concrete paths this task's spec forbids modifying (its `Do NOT modify`
      * CONSTRAINTS — see frozen-path-guard.ts / prohibition-probe.ts). Used to

package/dist/task/task-gates.js

@@ -1,6 +1,7 @@
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
 import { SessionUI } from '../remote/bridge.js';
 import { isYoloMode, yoloVerifyResolution, YOLO_STAMP } from './yolo.js';
+import { findRepairCandidate } from './root-cause-repair.js';
 /**
  * How many times a verify FAIL may be auto-fixed UNATTENDED (the research
  * recommended AUTOFIX, so pi re-runs the impl turn without prompting) before the
@@ -67,6 +68,39 @@ export async function runGatesForTask(ctxIn, deps, p) {
             // recording must never break the gate sequence
         }
     };
+    /**
+     * ROOT-CAUSE CHANNEL (mx5 run 14 item 5). Ask whether a FAIL was caused by a
+     * pre-existing defect in a file some OTHER task created and this task never
+     * touched. On a hit: record the durable debt (so the final gate surfaces it)
+     * and queue a scoped repair task (so something finally FIXES it — run 14
+     * recorded the same `test/teardown.ts` cause twice and scheduled nothing, and
+     * the bug survived ~24h). Returns the candidate so the caller can also decide
+     * NOT to punish the current task for it. Never throws: any fault degrades to
+     * null, i.e. exactly the pre-existing behavior.
+     */
+    const routeRootCause = async (failReason, rationale, scope) => {
+        if (!deps.touchedFiles || !deps.introducedBy)
+            return null;
+        try {
+            const candidate = await findRepairCandidate({
+                failReason,
+                rationale,
+                currentTaskId: p.taskId,
+                touched: await deps.touchedFiles(p.cwd, scope),
+                introducedBy: rel => deps.introducedBy(p.cwd, rel)
+            });
+            if (!candidate)
+                return null;
+            await deps.recordRootCauseDebt?.(p.cwd, p.taskId, `${failReason} — ROOT CAUSE: \`${candidate.file}\` (introduced by ${candidate.owner}, not touched by this task)`);
+            await deps.recordRepairCandidate?.(p.cwd, candidate);
+            await rec(`root-cause: FAIL attributed to \`${candidate.file}\` — a pre-existing defect in ${candidate.owner}'s file that this task never touched; `
+                + 'recorded as durable debt and a scoped repair task queued');
+            return candidate;
+        }
+        catch {
+            return null;
+        }
+    };
     const verdictLine = (v) => v.ok ?
         v.reason ?
             `verify: PASS (${v.reason})`
@@ -230,6 +264,11 @@ export async function runGatesForTask(ctxIn, deps, p) {
                         // recording must never break the gate sequence
                     }
                 }
+                // ROOT CAUSE: an accepted FAIL that some OTHER task's file caused is
+                // not fixed by accepting it — run 14 accepted this shape repeatedly
+                // and the causing bug outlived the whole run. Queue the scoped repair
+                // so the plan actually closes it.
+                await routeRootCause(failReason, recOutcome.rationale, 'worktree');
                 // Cross-task deletions the verify probe detected ship in the next
                 // commit with this ACCEPT — record each as its own durable debt so
                 // the final gate re-checks them (mx5 run 12 PROMPT 2). Best-effort.
@@ -413,7 +452,25 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 const after = deps.verify ?
                     await deps.verify(active, p.cwd, p.title, p.taskId)
                     : { ok: true };
-                if (!after.ok) {
+                const afterReason = after.reason ?? 'enforce re-verify failed';
+                // PRE-EXISTING-CAUSE KEEP PATH (mx5 run 14 item 5b). Both of run
+                // 14's enforce-reverts were this shape: the re-verify FAILed on
+                // TASK_0007's `test/teardown.ts` TRUNCATE bug — a file neither the
+                // task's work nor the enforce pass touched — and the differential
+                // reverted enforce's edits anyway, destroying good work over a fault
+                // it did not cause AND leaving the actual cause unscheduled. When the
+                // FAIL is attributed to another task's untouched file, KEEP the edits
+                // and route the real defect to a repair task instead. Everything
+                // unknown (git unavailable, no provenance, this task touched the file,
+                // an environment-blamed FAIL) falls through to the revert below —
+                // the conservative pre-existing behavior.
+                const rootCause = after.ok ? null : await routeRootCause(afterReason, '', 'committed');
+                if (!after.ok && rootCause) {
+                    await rec(`enforce: re-verify FAILED (${afterReason.slice(0, 200)}) but the failure is attributed to a PRE-EXISTING defect in \`${rootCause.file}\` `
+                        + `(${rootCause.owner}'s file, untouched by this task and by the enforce pass) — edits KEPT, not reverted; repair task queued`);
+                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on a pre-existing defect in ${rootCause.file} (${rootCause.owner}'s file) — keeping the fixes, queued a repair task.`, 'warning');
+                }
+                else if (!after.ok) {
                     if (deps.revert)
                         await deps.revert(p.cwd);
                     await rec(`enforce: fixes committed but re-verify FAILED (${(after.reason ?? 'now fails').slice(0, 200)}) — ${deps.revert ? 'REVERTED' : 'left in place (no revert available)'}`);

package/package.json

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