@mjasnikovs/pi-task 0.38.29 → 0.38.31

package/dist/task/task-gates.js

@@ -23,13 +23,12 @@ export const MAX_AUTO_AUTOFIX = 3;
 /**
  * The reason an auto-ACCEPT is being written — NAMED, not assumed.
  *
- * The line this replaces asserted "autofix budget spent" on every branch. It was
- * measured false in 2709 of 2709 recorded accepts (scripts/yolo-accept-baserate.ts):
- * the budget has never once reached MAX_AUTO_AUTOFIX anywhere in the corpus — 30%
- * of accepts are UNOBSERVED (the research is never even consulted) and 70% are an
- * ACCEPT recommendation with the budget fully untouched. A durable trail that
- * misstates why a defect shipped is worse than no trail: mx5 run 19's TASK_0009
- * reads as an exhausted fixer when nothing was ever attempted.
+ * Four disjoint branches reach the terminal auto-ACCEPT, and only ONE of them has
+ * spent the autofix budget. An UNOBSERVED FAIL never consults the research; a
+ * frozen-blocked one is a contradiction no re-run can resolve; an ACCEPT
+ * recommendation can arrive with the budget untouched. A single "autofix budget
+ * spent" line would be false on three of the four, and a durable trail that
+ * misstates why a defect shipped reads as an exhausted fixer that never tried.
  */
 export function yoloAcceptReason(c) {
     if (c.isUnobserved)
@@ -44,7 +43,7 @@ export function yoloAcceptReason(c) {
         : `judge recommended ACCEPT (autofix budget ${c.autoFixCount}/${MAX_AUTO_AUTOFIX} already spent)`;
 }
 // The trail-side output ceiling lives in clamp-output.ts, so the render probe's
-// evidence clamps identically (nexttask 19B) — one ceiling, one implementation.
+// evidence clamps identically — one ceiling, one implementation.
 /**
  * Show the boxed two-choice picker after a verify FAIL and return what the user
  * decided. The model-recommended card is placed first so the renderer tints it
@@ -73,12 +72,10 @@ export async function askVerifyResolution(ctx, title, failReason, rec) {
  * recommendation → unattended autofix → picker) until it verifies, is accepted,
  * or terminates.
  *
- * Split out of `runGatesForTask` at the single boolean that crosses to the
- * ENFORCE half. It carries 8 mutable locals over ~290 lines and has four terminal
- * exits; enforce carries one local and always falls through. Joining them meant a
- * test of the enforce differential had to traverse this whole loop first, which is
- * why `deps.verify` was driven by an invocation counter whose first return existed
- * only to unlock `mode === 'edit'`.
+ * Split from `runGatesForTask` at the single boolean that crosses to the ENFORCE
+ * half (`cleanPass`). This loop has four terminal exits and carries the whole
+ * negotiation; enforce always falls through. Joined, a test of the enforce
+ * differential would have to traverse this entire loop first.
  */
 export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
     let active = ctxIn;
@@ -107,9 +104,9 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
         let autoFixCount = 0;
         // Set when the bounded lint-fix reports the `frozen-path:` rejection: the
         // repo-health FAIL can only be fixed by editing a path THIS task's spec
-        // froze (mx5 run 12's unsatisfiable registration pair). An impl re-run is
-        // under the same freeze — rule 4b fails the task if it complies with the
-        // linter — so unattended AUTOFIX rounds CANNOT converge and are skipped;
+        // froze. An impl re-run happens under the same freeze — rule 4b fails the
+        // task if it complies with the linter — so unattended AUTOFIX rounds
+        // CANNOT converge and are skipped;
         // the picker is forced with the cross-task contradiction named, and the
         // defect is recorded as a durable debt for the final gate.
         let frozenContradiction = null;
@@ -202,10 +199,9 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                 // AUTOFIX must not bootstrap the full budget from it.
                 && !yoloRescueUsed;
             // YOLO, THE RESCUE BRANCH: the recommendation is ACCEPT, nobody can be
-            // asked, and the unattended budget is UNTOUCHED. Accepting here ships a
-            // defect having attempted nothing — mx5 run 19 did exactly that twice,
-            // and the final-gate autofix later fixed one of the two in a single pass
-            // (`0 pass 130 fail` → `121 pass 0 fail`). So spend ONE attempt first.
+            // asked, and the unattended budget is UNTOUCHED. Accepting here would
+            // ship a defect having attempted nothing, on a judgement the human who
+            // would normally weigh it never saw. So spend ONE attempt first.
             // Bounded by construction: one, not MAX_AUTO_AUTOFIX, so an ACCEPT
             // recommendation can never restart a full loop; if it still FAILs the
             // next turn falls through to the same auto-ACCEPT and the same debt.
@@ -226,8 +222,8 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             if (yoloChoice !== null) {
                 choice = yoloChoice;
                 // NAME the branch. This line is the durable record of why a defect
-                // shipped; asserting a spent budget on all four branches made run
-                // 19's zero-attempt accepts read as an exhausted fixer.
+                // shipped, and three of the four branches that reach it have spent
+                // no budget at all.
                 await rec(`resolution: auto-ACCEPTED despite verify FAIL — ${yoloAcceptReason({
                     isUnobserved,
                     isFrozenBlocked,
@@ -258,9 +254,9 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                 if (!byYolo)
                     await rec('resolution: user ACCEPTED the work despite verify FAIL');
                 // Durable debt: the human blessed a FAILing artifact as-is, so the
-                // defect ships and nothing else revisits it (mx5 run 4 B3 / run 8
-                // TASK_0012). Record it to the run ledger; the final integration gate
-                // re-checks it at run end and surfaces it if still open. Best-effort.
+                // defect ships and nothing else in this task revisits it. Record it
+                // to the run ledger; the final integration gate re-checks it at run
+                // end and surfaces it if still open. Best-effort.
                 // The frozen-blocked routing above already recorded this defect (with
                 // the contradiction named) — don't double-enter it in the ledger.
                 if (!frozenDebtRecorded) {
@@ -275,13 +271,12 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
                     }
                 }
                 // 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.
+                // not fixed by accepting it — every later task keeps tripping over
+                // the same bug. Queue the scoped repair so the plan 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.
+                // the final gate re-checks them. Best-effort.
                 for (const del of verified.crossTaskDeletions ?? []) {
                     try {
                         await deps.recordDebt?.(p.cwd, p.taskId, crossTaskDeletionReason(del), 'cross-task-deletion');
@@ -296,11 +291,10 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
             }
             // AUTOFIX: re-run the implementation turn with the failure (and any typed
             // guidance) prepended as a RE-ATTEMPT banner, then re-verify. The
-            // recommendation child already LOCATED the defect while deciding (mx5
-            // run 6: it pinned the exact SQL alias bug and the afterAll DB-drop) —
-            // hand that diagnosis to the re-run so it fixes the located cause
-            // instead of re-deriving it from the bare FAIL line. Skipped when there
-            // is no researched rationale beyond the failure text itself.
+            // recommendation child already LOCATED the defect while deciding, so
+            // hand its diagnosis to the re-run rather than making it re-derive the
+            // cause from the bare FAIL line. Skipped when there is no researched
+            // rationale beyond the failure text itself.
             // Only the picker branch may claim a person chose this: the two
             // unattended branches already recorded themselves one line above, and a
             // trail that says "user chose" when nobody was asked is the same lie the
@@ -362,8 +356,7 @@ export async function resolveVerifyGate(ctxIn, deps, p, rec, routeRootCause) {
  * then decide whether the pass\'s own commit survives.
  *
  * `reVerify` is deliberately NOT `deps.verify`. They answer two different
- * questions — the gate above, and this differential — and while they shared one
- * field the only way to answer them differently was to count invocations.
+ * questions — the gate above, and this differential — so they are two fields.
  *
  * Reads `active` and never reassigns it: nothing here can replace the live
  * session, unlike the autofix in the verify half.
@@ -378,19 +371,19 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
         const mode = verifyCleanPass ? 'edit' : 'flag';
         // BASELINE repo health, captured BEFORE the edit pass touches the tree, so the
         // pre-commit gate below is DIFFERENTIAL: it can tell an enforce-CAUSED
-        // regression (was clean, now fails) from a repo that was ALREADY unhealthy
-        // (run-8 F8: five enforce passes were discarded on a lint that was already
-        // crashing — exit 2 — before enforce edited anything; the discard threw away
-        // good work for a fault it did not cause). Only meaningful in edit mode (flag
+        // regression (was clean, now fails) from a repo that was ALREADY unhealthy.
+        // Without the baseline, a lint that was already crashing before the pass ran
+        // makes every enforce pass look like the cause, and its good work is
+        // discarded for a fault it did not commit. Only meaningful in edit mode (flag
         // makes no edits); the task's work is already committed so this reflects the
         // committed state the pass is about to build on.
         const healthBefore = mode === 'edit' && deps.repoHealth ?
             await deps.repoHealth(active, p.cwd, p.title)
             : undefined;
         const verdict = await deps.enforce(active, p.cwd, p.title, mode);
-        // FROZEN-PATH WRITE-DENY (mechanical, not prompt — the "MUST NOT edit"
-        // instruction is A/B-proven ~0–1/5 reliable on the weak model): the enforce
-        // EDIT pass runs read,edit and has been seen mutating a path the spec froze.
+        // FROZEN-PATH WRITE-DENY (mechanical, not prompt — a "MUST NOT edit"
+        // instruction is not reliable): the enforce EDIT pass runs read,edit and can
+        // mutate a path the spec froze.
         // Before its edits are inspected/committed below, restore any frozen path it
         // touched to the committed task state, so the violating write cannot land in
         // the ENFORCE GUIDELINES commit regardless of what the model intended. The
@@ -417,20 +410,21 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
         if (!verdict.ok) {
             active.ui.notify(`${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
         }
-        // PRE-COMMIT health gate on enforce edits: live data shows the edit pass broke
-        // the repo's own lint in 11/16 tasks, each burning a commit + model re-verify +
-        // revert cycle. A deterministic static check BEFORE committing skips the cycle
-        // and discards the bad edits outright. Only runs when the tree is actually
+        // PRE-COMMIT health gate on enforce edits: an edit pass that breaks the
+        // repo's own lint would otherwise burn a commit, a model re-verify and a
+        // revert before anything noticed. A deterministic static check BEFORE
+        // committing skips that cycle and discards the bad edits outright. Only runs
+        // when the tree is actually
         // dirty (or dirtiness is unknowable); the differential guard below still
         // catches behavioral regressions the static check cannot see.
         //
-        // The gate is DIFFERENTIAL, not absolute (run-8 F8): discard the edits only
+        // The gate is DIFFERENTIAL, not absolute: discard the edits only
         // when they REGRESSED the health signal — clean before, failing after. A repo
         // that was already failing before enforce ran is not enforce's fault, so its
-        // edits are KEPT (and the pre-existing failure is recorded, to be caught by the
-        // final integration gate, not blamed on this pass). The failing command's
-        // output is captured into the trail so the discard is explainable — F8 was
-        // unreproducible precisely because only the exit code was recorded.
+        // edits are KEPT (and the pre-existing failure is recorded, to be caught by
+        // the final integration gate, not blamed on this pass). The failing command's
+        // OUTPUT is captured into the trail, not just its exit code, so the discard
+        // is explainable after the run.
         let enforceEditsBlocked = false;
         if (mode === 'edit' && deps.repoHealth && editsMade !== false) {
             const after = await deps.repoHealth(active, p.cwd, p.title);
@@ -460,16 +454,15 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
             }
         }
         if (mode === 'edit' && !enforceEditsBlocked && editsMade === false) {
-            // KNOWN-clean tree (dirty dep ran and found no code edits): skip the
+            // KNOWN-clean tree (the dirty dep ran and found no code edits): skip the
             // enforce commit AND the differential re-verify outright. Without this
             // gate the commit is never empty — the .pi-tasks gate-trail lines written
-            // above make it real — so mx5 run 5 burned a full model re-verify on an
-            // UNCHANGED tree for all ~29 tasks, and the 10 FAILs those re-verifies
-            // produced (all real, pre-existing defects) were "reverted" into the
-            // void: the revert dropped a bookkeeping-only commit and the defect
-            // reports were discarded while the tasks stayed PASS. No edits ⇒ nothing
-            // to guard ⇒ no commit, no re-verify, no revert. The trail lines ride
-            // along in the next ordinary commit.
+            // above make it real — so every task would burn a model re-verify on an
+            // UNCHANGED tree, and any FAIL it turned up would be "reverted" into the
+            // void: the revert drops a bookkeeping-only commit while the defect
+            // report is discarded and the task stays PASS. No edits ⇒ nothing to
+            // guard ⇒ no commit, no re-verify, no revert. The trail lines ride along
+            // in the next ordinary commit.
             await rec('enforce(edit): no code edits — enforce commit and re-verify skipped');
         }
         else if (mode === 'edit' && !enforceEditsBlocked) {
@@ -484,30 +477,27 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                     await differential(active, p.cwd, p.title, p.taskId)
                     : { ok: true };
                 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 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
-                // 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.
+                // PRE-EXISTING-CAUSE KEEP PATH. A re-verify can FAIL on a file the
+                // enforce pass never touched — another task's bug this one merely
+                // ran into. Reverting there destroys good work over a fault it did
+                // not cause AND leaves the actual cause unscheduled. So when the FAIL
+                // is attributed to another task's untouched file, KEEP the edits and
+                // route the real defect to a repair task. Everything unknown (git
+                // unavailable, no provenance, this task touched the file, an
+                // environment-blamed FAIL) falls through to the revert below.
                 //
-                // 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.
+                // The scope is `enforce-commit`, NOT the task's own commit. 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.
                 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
+                // ATTRIBUTION PRE-FILTER. The root-cause channel above needs a blame
+                // CUE, a path-separator token and known provenance. A FAIL text can
+                // carry none of the three — a bare `MyListings.spec.tsx:186` names a
+                // file with no directory and no blame wording — and then falls
+                // 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
@@ -527,15 +517,14 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                 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.
+                    // touched file's own spec/story counts as inside). Discarding
+                    // the enforce commit could not repair this, so doing so only
+                    // costs the correct change the pass 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.
+                    // Keeping the edits must NOT lose the finding. Same durability
+                    // as the revert path; only the disposition of the edits differs.
                     await deps.recordDebt?.(p.cwd, p.taskId, afterReason, 'enforce-kept');
                     // …and, when the named file is somebody else's committed work,
                     // queue the scoped repair so something actually FIXES it.
@@ -571,12 +560,12 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
                                 ` — 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 —
-                    // erasing it with the enforce edits buried the terminal fault 8.5h
-                    // before run end. The final gate re-checks/surfaces it (static-class
-                    // auto-closes if a later task fixed the statics; else stays open).
+                    // Persist the FAIL as a durable defect. The revert restores the
+                    // tree the ORIGINAL verify already blessed, so this re-verify
+                    // caught something that verify's earlier PASS missed — erasing it
+                    // along with the enforce edits would bury a real fault. The final
+                    // gate re-checks and surfaces it (static-class auto-closes if a
+                    // later task fixed the statics; otherwise it stays open).
                     await deps.recordDebt?.(p.cwd, p.taskId, after.reason ?? 'enforce re-verify failed', 'enforce-revert');
                     active.ui.notify(`${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
                 }
@@ -593,7 +582,7 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
     }
     else if (deps.enforce) {
         // deps.enforce wired but nothing was committed this round — record the skip
-        // so a missing enforce run is explainable from the trail (mx5 audit gap).
+        // so a missing enforce run is explainable from the trail.
         await rec('enforce: skipped (nothing committed this round)');
     }
 }
@@ -607,12 +596,12 @@ export async function runGatesForTask(ctxIn, deps, p) {
         }
     };
     /**
-     * ROOT-CAUSE CHANNEL (mx5 run 14 item 5). Ask whether a FAIL was caused by a
+     * ROOT-CAUSE CHANNEL. 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
+     * and queue a scoped repair task, so something finally FIXES it rather than
+     * recording the same cause once per task that trips over it. 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.
      */
@@ -652,10 +641,10 @@ export async function runGatesForTask(ctxIn, deps, p) {
     if (commit.committed) {
         await rec(`commit: task snapshot committed${commit.note ? ` (${commit.note})` : ''}`);
         // SAY WHAT WAS LEFT OUT. The stage skips untracked regenerable test-runner
-        // output (mx5 run 20: TASK_0027's `git add -A` swept in three Playwright
-        // failure screenshots and two later fix attempts were rejected for deleting
-        // them). A SILENT exclusion is the same failure class as the silent
-        // ignored-path write nexttask 4 closed, so it gets its own trail line.
+        // output, so a blind `git add -A` cannot make a screenshot a tracked
+        // deliverable that a later fix attempt is then rejected for deleting. A
+        // SILENT exclusion is the same failure class as a silent ignored-path write,
+        // so it gets its own trail line.
         if (commit.excluded && commit.excluded.length > 0) {
             await rec(`commit: left ${commit.excluded.length} untracked test-runner artifact(s) out of the `
                 + `snapshot — regenerable output, not deliverables: `
@@ -668,8 +657,8 @@ export async function runGatesForTask(ctxIn, deps, p) {
         await rec(`commit: skipped (${commit.reason ?? 'unknown'})`);
         // A benign skip ("nothing to commit", auto-commit off) is a warning. A real
         // git failure is louder: it silently disables enforce AND every commit-based
-        // guard — mx5 run 4 lost all 10 commits (no container git identity) with only
-        // per-task warnings to show for it. "blocked" is the unmerged-index refusal
+        // guard, so a whole run can end with nothing committed and only per-task
+        // warnings to show for it. "blocked" is the unmerged-index refusal
         // (gitCommitAll) — the same severity: nothing can commit until it's resolved.
         const gitFailure = /^git (commit|add) (failed|blocked)/.test(commit.reason ?? '');
         active.ui.notify(gitFailure ?

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

@@ -24,10 +24,10 @@ export declare function setTaskSection(cwd: string, id: string, heading: string,
 /**
  * Append one timestamped line to the task's `## gates` section — the durable
  * per-task trail of gate outcomes (verify verdicts, enforce mode/verdict, commit
- * results). Motivated by the mx5 audit: verdict text lived only in memory and
- * terminal notifies, so "did enforce run for this task, and in which mode?" was
- * unanswerable from artifacts. Best-effort by design: a failure to record must
- * never break the gate sequence, so all errors are swallowed.
+ * results). A verdict that lives only in memory and a terminal notify cannot
+ * answer "did enforce run for this task, and in which mode?" after the run.
+ * Best-effort by design: a failure to record must never break the gate sequence,
+ * so all errors are swallowed.
  */
 export declare function appendGateRecord(cwd: string, id: string, line: string): Promise<void>;
 /** Remove a section (heading + body) if present; a no-op when it's absent. */

package/dist/task/task-io.js

@@ -115,10 +115,10 @@ export async function setTaskSection(cwd, id, heading, content) {
 /**
  * Append one timestamped line to the task's `## gates` section — the durable
  * per-task trail of gate outcomes (verify verdicts, enforce mode/verdict, commit
- * results). Motivated by the mx5 audit: verdict text lived only in memory and
- * terminal notifies, so "did enforce run for this task, and in which mode?" was
- * unanswerable from artifacts. Best-effort by design: a failure to record must
- * never break the gate sequence, so all errors are swallowed.
+ * results). A verdict that lives only in memory and a terminal notify cannot
+ * answer "did enforce run for this task, and in which mode?" after the run.
+ * Best-effort by design: a failure to record must never break the gate sequence,
+ * so all errors are swallowed.
  */
 export async function appendGateRecord(cwd, id, line) {
     try {

package/dist/task/task-parsers.js

@@ -33,9 +33,10 @@ export function emitFrontMatter(fm) {
 }
 export function parseFrontMatter(content) {
     // `\r?\n` throughout so a CRLF/Windows task file parses too. Reads normally
-    // pass through readTextFile (which normalizes to LF), but tolerating CRLF at
-    // the parser itself is the safety net for any read site that forgets to —
-    // exactly the class of miss that shipped in 0.17.8. See shared/fs-text.ts.
+    // pass through readTextFile (which normalizes CRLF and lone CR to LF), but
+    // tolerating CRLF at the parser itself is the safety net for any read site
+    // that forgets to. A lone CR still needs the normalization — no regex here
+    // matches it, because every one requires an `\n`. See shared/fs-text.ts.
     const m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/.exec(content);
     if (!m)
         return null;

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

@@ -39,7 +39,7 @@ export interface CrossTaskDeletion {
 export declare function findCrossTaskDeletions(changes: TreeChangeSummary, currentTaskId: string, introducedBy: (rel: string) => string | null | Promise<string | null>): Promise<CrossTaskDeletion[]>;
 /**
  * Finding lines for the verify prompt (the substitution-probe injection pattern:
- * the rule alone is A/B-proven ignored, the rule plus a concrete finding naming
- * the file is what lands).
+ * a rule on its own is ignored; the rule plus a concrete finding naming the
+ * file is what lands).
  */
 export declare function crossTaskDeletionVerifyFindings(found: CrossTaskDeletion[]): string[];

package/dist/task/task-provenance.js

@@ -1,23 +1,21 @@
 /**
  * task-provenance — file → introducing-task lookup, and the cross-task deletion
- * detection built on it (mx5 run-12 PROMPT 2).
+ * detection built on it.
  *
- * The failure class: write-enabled gate/fix children can DELETE a sibling task's
- * committed deliverable to turn a red check green. Live (mx5 2026-07-16,
- * verify-debug.log 17:53:44): `bun run lint` was permanently red because
- * committed playwright ct files were not registered in a spec-frozen tsconfig —
- * so a lint-fix child deleted TASK_0020's verified deliverables and the pass
- * returned ok. Every existing guard missed the class:
+ * The failure class: a write-enabled gate or fix child can DELETE a sibling
+ * task's committed deliverable to turn a red check green — a lint that only goes
+ * green once the offending files are gone. Every other guard misses that class:
  *
  *   - the lint-fix revert-guard checks only pre-DIRTY files reverted and
- *     pre-UNTRACKED files gone — a CLEAN tracked sibling file is in neither set;
+ *     pre-UNTRACKED files gone — a CLEAN tracked sibling file is in neither set
+ *     (lint-fix.ts says so at its own site);
  *   - the frozen-path guard covers only paths THIS task's spec froze;
- *   - the run-11 deletion guard covers only the final-fix child;
+ *   - `findForbiddenDeletions` (write-guard.ts) was reached only by the final-fix
+ *     child (final-gate-fix.ts);
  *   - the impl turn legitimately deletes files (its own refactors), so a blanket
  *     ban is wrong — the discriminator must be PROVENANCE: who introduced the file.
  *
- * The provenance primitive (extracted from final-gate.ts, where it fed the
- * conflicting-claim annotation) resolves a file to the task whose commit ADDED it
+ * The provenance primitive resolves a file to the task whose commit ADDED it
  * (`git log --diff-filter=A` → oldest task-subject commit). Every unknown — a file
  * predating the run, a non-task commit, any git error — degrades to null:
  * inconclusive is never evidence, so the guards built on this may only cost time,
@@ -90,8 +88,8 @@ export async function findCrossTaskDeletions(changes, currentTaskId, introducedB
 }
 /**
  * Finding lines for the verify prompt (the substitution-probe injection pattern:
- * the rule alone is A/B-proven ignored, the rule plus a concrete finding naming
- * the file is what lands).
+ * a rule on its own is ignored; the rule plus a concrete finding naming the
+ * file is what lands).
  */
 export function crossTaskDeletionVerifyFindings(found) {
     return found.map(f => `\`${f.path}\` — introduced and committed by ${f.owner}, DELETED by this task's work`);

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

@@ -15,9 +15,10 @@ export interface TaskFrontMatter {
     title: string;
     /**
      * Short, human-readable display label compressed from `title`. Visual only —
-     * `title` always holds the full text the pipeline reads. Absent on pre-label
-     * tasks and on small tasks whose title is already short; display falls back to
-     * a deterministic truncation of `title` when missing. See title-label.ts.
+     * `title` always holds the full text the pipeline reads. Absent on a task file
+     * written before the field existed, and on any task that never reached the
+     * phase that writes it; display then falls back to a deterministic truncation
+     * of `title` (`titleForDisplay`, parsers.ts). See title-label.ts.
      */
     label?: string;
     reason?: string;

package/dist/task/terminal-outcome.d.ts

@@ -2,19 +2,17 @@
  * What each way a gated task can END means for persistence and for what the user
  * is told — stated once, for both `/task` and `/task-auto`.
  *
- * `runGatesForTask` is already shared verbatim by the two commands, so both
- * consume the same five-kind outcome. What was NOT shared was the answer to the
- * three questions each kind raises: demote the inner task file? fail the parent
- * run file? what do we say, at what level? Those were two `switch`es 600 lines
- * apart with line-for-line correspondence — down to the identical
- * `reason.slice(0, 160)` truncation — differing only in the resume verb, whether
- * a parent run file exists to fail, and whether the message names the step.
+ * `runGatesForTask` is shared by the two commands, so both consume the same
+ * outcome union. Each kind raises the same three questions: demote the inner task
+ * file? fail the parent run file? what do we say, at what level? This table
+ * answers them once. It touches none of either loop's state — it is the
+ * outcome → (persistence, message) mapping and nothing else — and a new outcome
+ * kind is a compile error here rather than a silent fallthrough in whichever
+ * command was not updated.
  *
- * That is not the shared "task-runner base" CONTEXT.md rules out, and for the
- * same reason `runFinalGateStage` could leave `runAutoLoop`: this is the
- * outcome → (persistence, message) mapping, and it touches none of either loop's
- * state. Adding a sixth outcome kind is now a compile error in one place rather
- * than a silently-unhandled fallthrough in whichever command was not updated.
+ * The three things that genuinely differ per command are parameters: the resume
+ * verb, whether the message names a step (`/task` runs one task and passes an
+ * empty `at`), and whether a parent run file exists to fail.
  *
  * The PRE-gate outcomes (`res.sessionCancelled` / `res.interrupted` / `!res.ok`,
  * before the gate runs) are deliberately NOT here. Their wording genuinely
@@ -28,7 +26,7 @@
 export type TerminalOutcomeKind = 'done' | 'paused' | 'session-cancelled' | 'cancelled' | 'interrupted' | 'failed';
 /** What the message needs to name. */
 export interface TerminalMessageContext {
-    /** The task or run id shown to the user (`TASK_0007`, `AUTO_0002`, `Task`). */
+    /** The task or run id shown to the user. */
     tag: string;
     /**
      * The step this happened at, ALREADY formatted with its leading space —
@@ -45,7 +43,7 @@ export interface TerminalOutcome {
     /**
      * Demote the INNER task file to resumable. It reads `completed` from
      * spec-handoff, and leaving it that way is how a failed run's task file
-     * claimed success in the run 6 audit.
+     * claimed success after the run had failed.
      */
     markResumable: boolean;
     /**
@@ -58,8 +56,8 @@ export interface TerminalOutcome {
     message: (c: TerminalMessageContext) => string;
 }
 /**
- * Truncate a failure reason for a one-line notification, or produce nothing.
- * Both commands did this identically and inline.
+ * Truncate a failure reason for a one-line notification, or produce nothing when
+ * there is no reason.
  */
 export declare function formatWhy(reason?: string): string;
 /** The step suffix, or empty when the command has no step to name. */

package/dist/task/terminal-outcome.js

@@ -2,19 +2,17 @@
  * What each way a gated task can END means for persistence and for what the user
  * is told — stated once, for both `/task` and `/task-auto`.
  *
- * `runGatesForTask` is already shared verbatim by the two commands, so both
- * consume the same five-kind outcome. What was NOT shared was the answer to the
- * three questions each kind raises: demote the inner task file? fail the parent
- * run file? what do we say, at what level? Those were two `switch`es 600 lines
- * apart with line-for-line correspondence — down to the identical
- * `reason.slice(0, 160)` truncation — differing only in the resume verb, whether
- * a parent run file exists to fail, and whether the message names the step.
+ * `runGatesForTask` is shared by the two commands, so both consume the same
+ * outcome union. Each kind raises the same three questions: demote the inner task
+ * file? fail the parent run file? what do we say, at what level? This table
+ * answers them once. It touches none of either loop's state — it is the
+ * outcome → (persistence, message) mapping and nothing else — and a new outcome
+ * kind is a compile error here rather than a silent fallthrough in whichever
+ * command was not updated.
  *
- * That is not the shared "task-runner base" CONTEXT.md rules out, and for the
- * same reason `runFinalGateStage` could leave `runAutoLoop`: this is the
- * outcome → (persistence, message) mapping, and it touches none of either loop's
- * state. Adding a sixth outcome kind is now a compile error in one place rather
- * than a silently-unhandled fallthrough in whichever command was not updated.
+ * The three things that genuinely differ per command are parameters: the resume
+ * verb, whether the message names a step (`/task` runs one task and passes an
+ * empty `at`), and whether a parent run file exists to fail.
  *
  * The PRE-gate outcomes (`res.sessionCancelled` / `res.interrupted` / `!res.ok`,
  * before the gate runs) are deliberately NOT here. Their wording genuinely
@@ -25,8 +23,8 @@
  * overrides, which is not a simplification.
  */
 /**
- * Truncate a failure reason for a one-line notification, or produce nothing.
- * Both commands did this identically and inline.
+ * Truncate a failure reason for a one-line notification, or produce nothing when
+ * there is no reason.
  */
 export function formatWhy(reason) {
     return reason ? ` — ${reason.slice(0, 160)}` : '';