@mjasnikovs/pi-task 0.25.0 → 0.27.0

package/dist/task/task-gates.js

@@ -1,7 +1,8 @@
 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';
+import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
+import { attributeEnforceFailure } from './enforce-attribution.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
@@ -455,8 +456,8 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 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
+                // TASK_0007's `test/teardown.ts` TRUNCATE bug — a file the enforce
+                // pass never 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
@@ -464,16 +465,82 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 // 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');
+                //
+                // The scope is `enforce-commit`, NOT the task's own commit (mx5 run
+                // 18 / nexttask 4). This differential decides whether to discard the
+                // ENFORCE COMMIT, so the causal question is "could the enforce diff
+                // have caused this?" — asking what the TASK touched answers a
+                // question nobody at this seam is asking, and in run 18 it answered
+                // it in a way that destroyed a correct one-line change.
+                const rootCause = after.ok ? null : await routeRootCause(afterReason, '', 'enforce-commit');
+                // ATTRIBUTION PRE-FILTER (mx5 run 18 / nexttask 4). The root-cause
+                // channel above needs a blame CUE, a path-separator token and known
+                // provenance; run 18's FAIL text carried none of the three (it named
+                // a bare `MyListings.spec.tsx:186`), so it fell straight through to
+                // the revert. This filter asks only the mechanical question: does the
+                // failing check name any file the ENFORCE COMMIT touched? Disjoint =>
+                // the revert cannot repair the failure, so keep the edits and route
+                // the defect. Unknown diff, or a FAIL naming no file at all, still
+                // reverts — never keep on ignorance.
+                const attribution = !after.ok && !rootCause ?
+                    attributeEnforceFailure({
+                        failReason: afterReason,
+                        enforceTouched: (await deps.touchedFiles?.(p.cwd, 'enforce-commit')) ?? null,
+                        repoFiles: (await deps.repoFiles?.(p.cwd)) ?? null
+                    })
+                    : null;
                 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`);
+                        + `(${rootCause.owner}'s file, untouched by the ENFORCE COMMIT whose fate this differential decides) — 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 && attribution?.verdict === 'keep') {
+                    // KEEP, mechanically justified: every file the failing check named
+                    // is outside the enforce diff (and outside its companions — a
+                    // touched file's own spec/story counts as inside). Discarding the
+                    // enforce commit could not repair this, and in run 18 doing so
+                    // cost a correct change that the final gate then re-made.
+                    await rec(`enforce: re-verify FAILED (${afterReason.slice(0, 200)}) but the failing check names only \`${attribution.named.join(', ')}\`, `
+                        + `which the ENFORCE COMMIT does not touch (its diff: ${attribution.enforceDiff.join(', ') || '—'}) — `
+                        + 'reverting it could not repair this, so the edits are KEPT and the defect is recorded as durable debt');
+                    // Keeping the edits must NOT lose the finding — that was mx5 run
+                    // 5's mistake. Same durability as the revert path; only the
+                    // disposition of the edits differs.
+                    await deps.recordEnforceKeptDebt?.(p.cwd, p.taskId, afterReason);
+                    // …and, when the named file is somebody else's committed work,
+                    // queue the scoped repair so something actually FIXES it.
+                    if (attribution.file && deps.introducedBy && deps.recordRepairCandidate) {
+                        try {
+                            const owner = await deps.introducedBy(p.cwd, attribution.file);
+                            const verifyCommand = extractFailingCommand(afterReason);
+                            if (owner && owner !== p.taskId) {
+                                await deps.recordRepairCandidate(p.cwd, {
+                                    file: attribution.file,
+                                    owner,
+                                    defect: summariseDefect(afterReason, attribution.file),
+                                    blamedTask: p.taskId,
+                                    ...(verifyCommand ? { verifyCommand } : {})
+                                });
+                                await rec(`root-cause: \`${attribution.file}\` is ${owner}'s file — scoped repair task queued`);
+                            }
+                        }
+                        catch {
+                            // queueing a repair must never break the gate sequence
+                        }
+                    }
+                    active.ui.notify(`${p.tag}: guideline fixes on "${p.title}" re-verified red on ${attribution.file ?? 'a file'} — outside the enforce diff, so keeping the fixes and recording the defect.`, '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)'}`);
+                    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)'}`
+                        // Why the attribution filter did NOT save the edits, so a
+                        // revert is explainable from the trail alone.
+                        + (attribution ?
+                            ` [attribution: ${attribution.why}${attribution.overlap ?
+                                ` — the check names \`${attribution.overlap.named}\`, the enforce diff touches \`${attribution.overlap.enforce}\``
+                                : ''}]`
+                            : ''));
                     // Persist the FAIL as a durable defect (mx5 run 10 item 3). The
                     // revert restores the tree the ORIGINAL verify already blessed, so
                     // this re-verify caught a defect that verify's earlier PASS missed —

package/package.json

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