@mjasnikovs/pi-task 0.42.4 → 0.42.6

package/dist/task/accept-debt.js

@@ -36,6 +36,7 @@ import * as path from 'node:path';
 import * as fsp from 'node:fs/promises';
 import { runVerifyCommandLine, spawnCommand } from './command-run.js';
 import { failClassOfReason, isHealthClass, isStaticClass } from './verify-work.js';
+import { discoverTestCommands } from './repo-health-check.js';
 import { taskThatIntroduced } from './task-provenance.js';
 import { makeLedger } from './ledger.js';
 import { parseVerifyBlockStrict } from './spec-validation.js';
@@ -341,6 +342,9 @@ function isStorableCommand(cmd) {
  * command with fabricated provenance, which is the one thing this class may not do.
  */
 export async function classifyVerifyCommand(cwd, taskId, reason) {
+    const suite = suiteCommandFromReason(cwd, reason);
+    if (suite !== null)
+        return suite;
     if (taskId.trim().length === 0)
         return null;
     try {
@@ -355,6 +359,23 @@ export async function classifyVerifyCommand(cwd, taskId, reason) {
         return null;
     }
 }
+/**
+ * The command a `test suite:` reason names, when the repo's own check is what
+ * discovers it. The suite is not a task's VERIFY line — it belongs to the repo —
+ * so without this the class has NO closure path at all: a passing lint may not
+ * close it (that is why the class exists), the run-end static check does not run
+ * the suite, and a repair splices only for a task's own regression. An inherited
+ * red suite was then reported open for the rest of the run after it went green.
+ *
+ * Provenance is the manifest: the span must equal a command `discoverTestCommands`
+ * produced, exactly as the VERIFY-block match must equal a parsed line.
+ */
+function suiteCommandFromReason(cwd, reason) {
+    if (failClassOfReason(reason) !== 'test-suite')
+        return null;
+    const hit = verifyCommandFromReason(reason, discoverTestCommands(cwd).cmds.map(([bin, args]) => `${bin} ${args.join(' ')}`));
+    return hit !== null && isStorableCommand(hit) ? hit : null;
+}
 export function verifyCommandFromReason(reason, verifyCommands) {
     const byText = new Map();
     for (const c of verifyCommands) {
@@ -395,6 +416,19 @@ export async function recheckAcceptDebts(debts, opts) {
     const resolved = [];
     const trail = [];
     let rerunsLeft = MAX_VERIFY_RERUNS;
+    const ran = new Map();
+    const settle = (d, cmd, r) => {
+        if (r.outcome === 'pass') {
+            resolved.push(d);
+            trail.push(`${d.taskId}: RESOLVED — re-ran \`${cmd}\` and it exited 0`);
+            return;
+        }
+        trail.push(`${d.taskId}: still open — re-ran \`${cmd}\`: `
+            + (r.outcome === 'fail' ?
+                `it FAILED${r.detail ? ` (${r.detail})` : ''}`
+                : `INCONCLUSIVE${r.detail ? ` (${r.detail})` : ''}, nothing was observed`));
+        open.push(d);
+    };
     for (const d of debts) {
         if (d.origin === 'cross-task-deletion') {
             const p = extractDeletedDebtPath(d.reason);
@@ -423,6 +457,15 @@ export async function recheckAcceptDebts(debts, opts) {
             open.push(d);
             continue;
         }
+        // One command, one run. A run that inherits a red suite records the same
+        // `bun run test` against every task in it, and re-running it once per debt
+        // would spend the whole budget proving the same thing and leave the rest
+        // open. The budget counts commands, which is what it was for.
+        const already = ran.get(cmd);
+        if (already !== undefined) {
+            settle(d, cmd, already);
+            continue;
+        }
         if (rerunsLeft <= 0) {
             trail.push(`${d.taskId}: NOT re-checked — the per-run re-run budget `
                 + `(${MAX_VERIFY_RERUNS}) is spent; the debt stays open`);
@@ -438,16 +481,8 @@ export async function recheckAcceptDebts(debts, opts) {
             // A harness fault observes nothing, so it proves nothing.
             r = { outcome: 'gap', detail: 're-run harness fault' };
         }
-        if (r.outcome === 'pass') {
-            resolved.push(d);
-            trail.push(`${d.taskId}: RESOLVED — re-ran \`${cmd}\` and it exited 0`);
-            continue;
-        }
-        trail.push(`${d.taskId}: still open — re-ran \`${cmd}\`: `
-            + (r.outcome === 'fail' ?
-                `it FAILED${r.detail ? ` (${r.detail})` : ''}`
-                : `INCONCLUSIVE${r.detail ? ` (${r.detail})` : ''}, nothing was observed`));
-        open.push(d);
+        ran.set(cmd, r);
+        settle(d, cmd, r);
     }
     return { open, resolved, trail };
 }

package/dist/task/deferred-breakage.d.ts

@@ -11,12 +11,11 @@
  * The phrases are the ones a model reaches for when it wants to defer, not the
  * word "test" — "add a test later" is a plan, not a deferral.
  *
- * SCOPE IS GRAMMATICAL, never a character count. A negation or a conditional
- * cancels a phrase only inside the phrase's own clause: "rather than flag it as a
- * known issue" rejects the phrase, and "without touching the test file, accepting
- * that it fails" does not. "Known issue", "follow-up" and "a later step" also name
- * legitimate plans — an upstream bug, a scope cut — so they count only in a clause
- * about a check.
+ * SCOPE IS GRAMMATICAL, never a character count. A negation cancels a phrase only
+ * inside the phrase's own clause: "rather than flag it as a known issue" rejects
+ * the phrase, and "without touching the test file, accepting that it fails" does
+ * not. "Known issue", "follow-up" and "a later step" also name legitimate plans —
+ * an upstream bug, a scope cut — so they count only in a clause about a check.
  */
 export declare function defersBreakage(answer: string): boolean;
 /** The one re-ask a deferring answer gets before it is surfaced instead of promoted. */

package/dist/task/deferred-breakage.js

@@ -11,23 +11,31 @@
  * The phrases are the ones a model reaches for when it wants to defer, not the
  * word "test" — "add a test later" is a plan, not a deferral.
  *
- * SCOPE IS GRAMMATICAL, never a character count. A negation or a conditional
- * cancels a phrase only inside the phrase's own clause: "rather than flag it as a
- * known issue" rejects the phrase, and "without touching the test file, accepting
- * that it fails" does not. "Known issue", "follow-up" and "a later step" also name
- * legitimate plans — an upstream bug, a scope cut — so they count only in a clause
- * about a check.
+ * SCOPE IS GRAMMATICAL, never a character count. A negation cancels a phrase only
+ * inside the phrase's own clause: "rather than flag it as a known issue" rejects
+ * the phrase, and "without touching the test file, accepting that it fails" does
+ * not. "Known issue", "follow-up" and "a later step" also name legitimate plans —
+ * an upstream bug, a scope cut — so they count only in a clause about a check.
  */
 /** A test, or a static check that the same clause calls broken. */
 const TEST_NOUN = /\b(?:tests?|suites?|assertions?)\b/i;
 const BUILD_NOUN = /\b(?:lint|linter|typecheck|build|ci)\b/i;
 const FAILURE = /\b(?:fail\w*|red|broken|breaks?|breakage|errors?)\b/i;
-/** Before a phrase in its clause: the phrase is rejected, or it is what an option
- *  WOULD do — "IF NOT EXISTS would still leave the test failing" weighs an option. */
-const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather than|instead of|isn't|is not|without|avoid|avoiding|would|could|might)\b/i;
-/** Where one clause ends and the next begins. */
-const CLAUSE_BOUNDARY = /[,:()]|\s[—–-]\s|\b(?:and|but|so|then|while|whereas|although|though|because|since|however)\b/gi;
-const SENTENCE_BOUNDARY = /[.!?](?=\s|$)|;|\n/;
+/** Before a phrase in its clause: the phrase is rejected. */
+const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather than|instead of|isn't|is not|without|avoid|avoiding)\b/i;
+/**
+ * A modal cancels a phrase only where the condition's own half of the sentence
+ * poses an option for it to weigh: "IF NOT EXISTS would still leave the test
+ * failing" describes what a rejected option does. A bare hedge does not — "I
+ * would flag it as a known issue" is the decision, and treating every modal as
+ * hypothetical let the guard be rephrased away.
+ */
+const MODAL = /\b(?:would|could|might)\b/i;
+const HYPOTHETICAL = /\b(?:if|unless|either|whether|option|alternative|otherwise)\b/i;
+/** Where one clause ends and the next begins. A semicolon joins clauses of ONE
+ *  thought, so the breakage a clause defers may sit in the other half. */
+const CLAUSE_BOUNDARY = /[,:;()]|\s[—–-]\s|\b(?:and|but|so|then|while|whereas|although|though|because|since|however)\b/gi;
+const SENTENCE_BOUNDARY = /[.!?](?=\s|$)|\n/;
 const PHRASES = [
     { re: /\b(?:test|suite)[- ]owners?\b/i, needs: 'alone' },
     {
@@ -43,9 +51,18 @@ const PHRASES = [
         needs: 'alone'
     },
     { re: /\baccept(?:s|ed|ing)?\b.*?\b(?:fail\w*|red|broken)\b/i, needs: 'check' },
+    // Handing the work to an unnamed someone is the deferral itself, whatever the
+    // clause is about; bare `whoever` below still needs a check to be one.
+    { re: /\bwhoever\s+(?:owns|revisits|maintains|touches)\b/i, needs: 'alone' },
+    // Ownership handed to a ROLE is handed to nobody. Handed to a named team it is
+    // handed to someone, so it counts only where the clause is about a check.
+    {
+        re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\s+(?:whoever|someone|somebody|another\b|a\s+later\b|the\s+(?:\w+\s+)?(?:owners?|maintainers?)\b)/i,
+        needs: 'alone'
+    },
+    { re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'check' },
     { re: /\bwhoever\b/i, needs: 'check' },
     { re: /\bowned\s+(?:by|follow[- ]?up)\b/i, needs: 'check' },
-    { re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'check' },
     { re: /\bleft\s+for\b/i, needs: 'check' },
     { re: /\bknown[- ]issues?\b/i, needs: 'check' },
     { re: /\bfollow[- ]?ups?\b/i, needs: 'check' },
@@ -83,18 +100,27 @@ function clauses(sentence) {
 export function defersBreakage(answer) {
     for (const sentence of prose(answer).split(SENTENCE_BOUNDARY)) {
         const sentenceBreaks = aboutACheck(sentence) && FAILURE.test(sentence);
-        for (const clause of clauses(sentence)) {
-            for (const { re, needs } of PHRASES) {
-                const hit = re.exec(clause);
-                if (!hit)
-                    continue;
-                if (NOT_A_DECISION.test(clause.slice(0, hit.index)))
-                    continue;
-                if (needs === 'check' && !aboutACheck(clause))
-                    continue;
-                if (needs === 'breakage' && !sentenceBreaks)
-                    continue;
-                return true;
+        // A condition governs its own half of a semicolon. It joins two independent
+        // clauses, so "the test fails only if X; I would flag it as known" states a
+        // condition and then decides — the decision is not one of X's options.
+        for (const half of sentence.split(';')) {
+            const weighsOptions = HYPOTHETICAL.test(half);
+            for (const clause of clauses(half)) {
+                for (const { re, needs } of PHRASES) {
+                    const hit = re.exec(clause);
+                    if (!hit)
+                        continue;
+                    const before = clause.slice(0, hit.index);
+                    if (NOT_A_DECISION.test(before))
+                        continue;
+                    if (MODAL.test(before) && weighsOptions)
+                        continue;
+                    if (needs === 'check' && !aboutACheck(clause))
+                        continue;
+                    if (needs === 'breakage' && !sentenceBreaks)
+                        continue;
+                    return true;
+                }
             }
         }
     }

package/dist/task/gate-deps.d.ts

@@ -27,6 +27,17 @@ export type FinalGateFixFn = (ctx: ExtensionCommandContext, cwd: string, failRea
  *  FinalFixDeps.ignoredKnown) — a failed attempt's ignored writes survive its
  *  discard and can green a later attempt. */
 ignoredKnown?: string[]) => Promise<FinalFixResult>;
+/**
+ * A file the suite wrote as the repo's OWN record, not as a report about the run.
+ * A test added this task and never run locally generates its snapshot on the
+ * gate's run; deleting it commits a snapshot test with no snapshot, and the next
+ * suite — or CI — fails on a file the task was supposed to carry.
+ *
+ * A named set, not a shape test: the alternative is an allowlist of throwaway
+ * artefacts, and anything it misses rides into the commit, which is the problem
+ * the cleanup exists for. A stray snapshot is the smaller error.
+ */
+export declare function isSuiteRecord(rel: string): boolean;
 /**
  * Collect the task's changed files as pure GIT SHAPE — path + added-line count,
  * no content, no language parsing — for the self-verification probe. Before the

package/dist/task/gate-deps.js

@@ -82,6 +82,21 @@ export function truncateToolResult(text, limit = TOOL_RESULT_LOG_LIMIT) {
 }
 /** Keep the gate machinery's own artifacts out of every git pathspec below. */
 const EXCLUDE_TASKS_DIR = ':(exclude).pi-tasks';
+/**
+ * A file the suite wrote as the repo's OWN record, not as a report about the run.
+ * A test added this task and never run locally generates its snapshot on the
+ * gate's run; deleting it commits a snapshot test with no snapshot, and the next
+ * suite — or CI — fails on a file the task was supposed to carry.
+ *
+ * A named set, not a shape test: the alternative is an allowlist of throwaway
+ * artefacts, and anything it misses rides into the commit, which is the problem
+ * the cleanup exists for. A stray snapshot is the smaller error.
+ */
+export function isSuiteRecord(rel) {
+    return (/(?:^|[\\/])__(?:snapshots|image_snapshots)__[\\/]/.test(rel)
+        || /\.snap$/.test(rel)
+        || /\.approved\.[^.\\/]+$/.test(rel));
+}
 /**
  * Pin the diff header prefixes on any command whose output we PARSE for paths.
  *
@@ -730,7 +745,8 @@ export function buildGateDeps(params) {
     // The project's own checks, suite included, once per tree for the run. A suite
     // writes coverage, reports and databases into the tree; left there, they ride
     // into the task's commit and read as enforce edits, so what the check created
-    // is removed before the tree is hashed again.
+    // is removed before the tree is hashed again — except what it wrote as the
+    // repo's own record (see isSuiteRecord).
     const gateHealth = (cwd2, onCommand) => currentRunContext(cwd2).healthFor(async () => {
         const before = await untrackedFiles(cwd2);
         try {
@@ -739,7 +755,7 @@ export function buildGateDeps(params) {
         finally {
             const after = before ? await untrackedFiles(cwd2) : null;
             for (const rel of after ?? []) {
-                if (!before?.has(rel)) {
+                if (!before?.has(rel) && !isSuiteRecord(rel)) {
                     await fsp
                         .rm(path.join(cwd2, rel), { recursive: true, force: true })
                         .catch(() => { });

package/dist/task/health-baseline.d.ts

@@ -38,6 +38,19 @@ export type HealthDelta = 'clean' | 'regressed' | 'pre-existing';
  * default the enforce site used to carry.
  */
 export declare function classifyHealthDelta(baseline: HealthSignal | null, after: HealthSignal): HealthDelta;
+/**
+ * Test commands the baseline RAN that now find no tests to run.
+ *
+ * A runner that found nothing observed nothing, which is a gap — in isolation. A
+ * task that deleted the test directory, renamed it, or broke the config's glob
+ * leaves the same gap, and the check reports the repo healthy because a gap never
+ * fails. Against a baseline that ran the suite, the suite is gone: this task's
+ * regression, and the largest one it can hide behind a green.
+ *
+ * Ran, not passed. A baseline that ran the suite RED ran it, and deleting a red
+ * suite is the same move with a larger payoff: the whole check turns green.
+ */
+export declare function vanishedSuites(baseline: HealthSignal | null, after: HealthSignal): HealthCommandResult[];
 /** The failing commands the baseline did not have failing the same way — what a
  *  `regressed` verdict is about. Every failing command when there is no baseline. */
 export declare function regressedCommands(baseline: HealthSignal | null, after: HealthSignal): HealthCommandResult[];

package/dist/task/health-baseline.js

@@ -41,6 +41,8 @@ function failures(signal) {
  * default the enforce site used to carry.
  */
 export function classifyHealthDelta(baseline, after) {
+    if (vanishedSuites(baseline, after).length > 0)
+        return 'regressed';
     if (after.ok)
         return 'clean';
     if (!baseline)
@@ -55,11 +57,32 @@ export function classifyHealthDelta(baseline, after) {
     return regressedCommands(baseline, after).length > 0 ? 'regressed' : 'pre-existing';
 }
 const failureKey = (c) => JSON.stringify([c.cmd, c.exitCode]);
+/**
+ * Test commands the baseline RAN that now find no tests to run.
+ *
+ * A runner that found nothing observed nothing, which is a gap — in isolation. A
+ * task that deleted the test directory, renamed it, or broke the config's glob
+ * leaves the same gap, and the check reports the repo healthy because a gap never
+ * fails. Against a baseline that ran the suite, the suite is gone: this task's
+ * regression, and the largest one it can hide behind a green.
+ *
+ * Ran, not passed. A baseline that ran the suite RED ran it, and deleting a red
+ * suite is the same move with a larger payoff: the whole check turns green.
+ */
+export function vanishedSuites(baseline, after) {
+    if (!baseline)
+        return [];
+    const ran = new Set((baseline.commands ?? []).filter(c => c.outcome !== 'skip').map(c => c.cmd));
+    return (after.commands ?? []).filter(c => c.outcome === 'skip' && c.gap === 'empty-suite' && ran.has(c.cmd));
+}
 /** The failing commands the baseline did not have failing the same way — what a
  *  `regressed` verdict is about. Every failing command when there is no baseline. */
 export function regressedCommands(baseline, after) {
     const wasFailing = new Set(baseline ? failures(baseline).map(failureKey) : []);
-    return failures(after).filter(c => !wasFailing.has(failureKey(c)));
+    return [
+        ...failures(after).filter(c => !wasFailing.has(failureKey(c))),
+        ...vanishedSuites(baseline, after)
+    ];
 }
 /**
  * The failing commands, as prompt/trail lines naming the exit code. A test

package/dist/task/health-repair.d.ts

@@ -22,7 +22,7 @@
  * because its script is a placeholder `exit 1`, and no repair task can fix either.
  */
 import type { HealthSignal } from './health-baseline.js';
-import type { HealthCommandResult } from './repo-health-check.js';
+import { type HealthCommandResult } from './repo-health-check.js';
 /** The failing check, and what its output named. */
 export interface HealthRed {
     command: string;
@@ -36,9 +36,13 @@ export interface HealthRedOwners {
     owners: string[];
 }
 /**
- * What a red health result is about: its first failing command that `mayRepair`
+ * What a red health result is about: its first red command that `mayRepair`
  * admits. Null when there is none — a legacy baseline, a signal with no
  * per-command detail, or only reds no repair can fix — so nothing to pin to.
+ *
+ * A vanished suite is red here though it failed nothing and left `ok` true. It
+ * is the regression the differential exists to catch, and without a subject
+ * ACCEPT queued no repair for it and the checkpoint spliced none.
  */
 export declare function healthRedSubject(health: HealthSignal & {
     output?: string;

package/dist/task/health-repair.js

@@ -1,3 +1,4 @@
+import { isHealthRed } from './repo-health-check.js';
 import { parseRepairTitleFile } from './root-cause-repair.js';
 import { failClassOfReason } from './verify-work.js';
 /** A path-like token: at least one directory separator, ending in a file name. */
@@ -23,12 +24,16 @@ function resolveTracked(token, cwd, tracked) {
     return bySuffix.length === 1 ? bySuffix[0] : null;
 }
 /**
- * What a red health result is about: its first failing command that `mayRepair`
+ * What a red health result is about: its first red command that `mayRepair`
  * admits. Null when there is none — a legacy baseline, a signal with no
  * per-command detail, or only reds no repair can fix — so nothing to pin to.
+ *
+ * A vanished suite is red here though it failed nothing and left `ok` true. It
+ * is the regression the differential exists to catch, and without a subject
+ * ACCEPT queued no repair for it and the checkpoint spliced none.
  */
 export function healthRedSubject(health, cwd, tracked, mayRepair = () => true) {
-    const failing = (health.commands ?? []).find(c => c.outcome === 'fail' && mayRepair(c));
+    const failing = (health.commands ?? []).find(c => isHealthRed(c) && mayRepair(c));
     if (!failing)
         return null;
     const files = [];

package/dist/task/repo-health-check.d.ts

@@ -1,4 +1,4 @@
-import { type CommandRunner } from './command-run.js';
+import { type CommandGapId, type CommandRunner } from './command-run.js';
 /**
  * What ONE discovered command did. `outcome` is `classifyCommandRun`'s verdict, so
  * a tool that could not run at all is `skip` rather than a zero-exit pass.
@@ -18,6 +18,9 @@ export interface HealthCommandResult {
     /** Absent on a record written before the suite joined the check, which ran
      *  statics only. A test red is judged, owed and repaired differently. */
     kind?: 'static' | 'test';
+    /** Why nothing was observed, on a `skip`. The differential reads it: a runner
+     *  that found no tests is a gap alone and a regression against a suite. */
+    gap?: CommandGapId;
     /** This command's own captured output, on a `fail` only. */
     output?: string;
 }
@@ -112,5 +115,7 @@ export declare function runRepoHealthCheck(cwd: string, opts?: {
      *  that will judge the result DIFFERENTIALLY may set this — see the header. */
     withTests?: boolean;
 }): Promise<HealthOutcome>;
+/** A command the repo owes an answer for: it failed, or its suite went missing. */
+export declare function isHealthRed(c: HealthCommandResult): boolean;
 /** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
 export declare function describeHealthFailures(commands: readonly HealthCommandResult[]): string;

package/dist/task/repo-health-check.js

@@ -125,9 +125,16 @@ export function discoverHealthCommands(cwd) {
     }
     return { ecosystem: null, cmds: [] };
 }
-/** `test:watch`, `jest --watchAll`, `vitest watch`, `bun test --watch`. */
+/**
+ * `test:watch`, `jest --watchAll`, `vitest watch`, `bun test --watch`.
+ *
+ * The flag is read by its VALUE, not its presence: `--watchAll=false` is how a CI
+ * script turns watch off, and excluding it drops the only `test` script such a
+ * repo has.
+ */
 function isWatchScript(name, body) {
-    return (/watch/i.test(name) || /(?:^|\s)--watch(?:All)?(?=[\s=]|$)|(?:^|\s)watch(?=\s|$)/.test(body));
+    return (/watch/i.test(name)
+        || /(?:^|\s)--watch(?:All)?(?:=(?:true|1))?(?=\s|$)|(?:^|\s)watch(?=\s|$)/.test(body));
 }
 /**
  * The project's OWN test commands, in the order the run-end gate runs them. One
@@ -242,7 +249,8 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
                 cmd,
                 outcome: passed ? 'pass' : 'skip',
                 exitCode: passed ? 0 : null,
-                kind
+                kind,
+                ...(verdict.outcome === 'gap' ? { gap: verdict.gap } : {})
             });
             continue;
         }
@@ -272,10 +280,16 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
         output: ''
     };
 }
+/** A command the repo owes an answer for: it failed, or its suite went missing. */
+export function isHealthRed(c) {
+    return c.outcome === 'fail' || c.gap === 'empty-suite';
+}
 /** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
 export function describeHealthFailures(commands) {
     return commands
-        .filter(c => c.outcome === 'fail')
-        .map(c => `\`${c.cmd}\` exited ${c.exitCode}`)
+        .filter(isHealthRed)
+        .map(c => c.outcome === 'fail' ?
+        `\`${c.cmd}\` exited ${c.exitCode}`
+        : `\`${c.cmd}\` found no tests to run`)
         .join('; ');
 }

package/dist/task/task-gates.js

@@ -1,11 +1,12 @@
 import { verifyFailClass } from './verify-work.js';
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
 import { resolveDisposition } from './gate-resolution.js';
-import { classifyHealthDelta } from './health-baseline.js';
+import { classifyHealthDelta, regressedCommands } from './health-baseline.js';
 import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, YOLO_STAMP } from './yolo.js';
 import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
 import { attributeEnforceFailure } from './enforce-attribution.js';
+import { describeHealthFailures } from './repo-health-check.js';
 import { healthRedSubject, parseHealthRepairTitle } from './health-repair.js';
 // The debt ledger is reached through the injected `recordDebt` dep (so it stays
 // absent-in-tests); only the origin TYPE and the cross-task-deletion reason SHAPE
@@ -417,15 +418,19 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
             const delta = classifyHealthDelta(healthBefore ?? null, after);
             if (delta === 'regressed') {
                 enforceEditsBlocked = true;
+                // What REGRESSED, not the check's own verdict: a vanished suite fails
+                // nothing, so `after.reason` reads "tests passed" under this discard.
+                const regressed = regressedCommands(healthBefore ?? null, after);
+                const why = regressed.length > 0 ? describeHealthFailures(regressed) : after.reason;
                 const outputTail = after.output ? ` — output:\n${clampOutput(after.output)}` : '';
                 if (deps.discardEdits) {
                     await deps.discardEdits(p.cwd);
-                    await rec(`enforce: edits discarded pre-commit — REGRESSED repo health (${after.reason})${outputTail}`);
+                    await rec(`enforce: edits discarded pre-commit — REGRESSED repo health (${why})${outputTail}`);
                 }
                 else {
-                    await rec(`enforce: edits REGRESSED repo health pre-commit (${after.reason}) — no discard available, left uncommitted${outputTail}`);
+                    await rec(`enforce: edits REGRESSED repo health pre-commit (${why}) — no discard available, left uncommitted${outputTail}`);
                 }
-                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
+                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${why.slice(0, 120)}) — discarded before commit.`, 'warning');
             }
             else if (delta === 'pre-existing') {
                 // Failing both before and after → not enforce's fault. Keep the edits;

package/dist/task/verify-work.d.ts

@@ -65,9 +65,12 @@ export interface VerifyFail {
     crossTaskDeletions?: CrossTaskDeletion[];
     inheritedHealth?: string;
     /** The health result behind a `repo-health` FAIL: which command, and what its
-     *  output named. What an ACCEPT of this FAIL hands to the repair channel. */
+     *  output named. What an ACCEPT of this FAIL hands to the repair channel.
+     *  `reason` describes what REGRESSED, which is not what the check itself said:
+     *  a vanished suite fails nothing, so the check's verdict reads "tests passed". */
     health?: HealthSignal & {
         output?: string;
+        reason?: string;
     };
     /** What the deterministic probes found for THIS verdict, carried out so an
      *  AUTOFIX re-run is told what the gate already knows (see fix-context.ts)

package/dist/task/verify-work.js

@@ -918,7 +918,12 @@ export async function runWorkVerification(deps) {
     if (deps.repoHealth) {
         stage('repo health');
         const h = await deps.repoHealth();
-        if (!h.ok) {
+        // `ok` is not the whole verdict: a suite this tree no longer finds observes
+        // nothing, so nothing fails, and only the differential sees it went away.
+        // Establishing a baseline can cost a worktree health run, so it is asked for
+        // only in the two shapes it can speak to.
+        const suiteGone = (h.commands ?? []).some(c => c.gap === 'empty-suite');
+        if (!h.ok || suiteGone) {
             const baseline = deps.healthBaseline ? await deps.healthBaseline() : null;
             const before = baseline?.outcome ?? null;
             if (classifyHealthDelta(before, h) === 'regressed') {
@@ -934,19 +939,30 @@ export async function runWorkVerification(deps) {
                     };
                 }
                 const failClass = healthFailClass(regressed);
+                // Re-minted, never `h.reason`: a vanished suite fails nothing, so the
+                // check's own reason reads "tests passed" under a REGRESSED verdict.
+                const why = describeHealthFailures(regressed);
                 return {
                     ok: false,
                     failClass,
-                    reason: `${VERIFY_FAIL_PREFIX[failClass]} ${describeHealthFailures(regressed)}`,
-                    health: { ...h, commands: regressed, output: regressed[0].output ?? h.output }
+                    reason: `${VERIFY_FAIL_PREFIX[failClass]} ${why}`,
+                    health: {
+                        ...h,
+                        ok: false,
+                        reason: why,
+                        commands: regressed,
+                        output: regressed[0].output ?? h.output
+                    }
                 };
             }
-            pre.repoHealth = inheritedHealthFindings(h);
-            const failing = h.commands?.filter(c => c.outcome === 'fail') ?? [];
-            inheritedHealth =
-                failing.length > 0 ?
-                    `${VERIFY_FAIL_PREFIX[healthFailClass(failing)]} ${describeHealthFailures(failing)} — already failing before this task`
-                    : `repo health: ${h.reason} — already failing before this task`;
+            if (!h.ok) {
+                pre.repoHealth = inheritedHealthFindings(h);
+                const failing = h.commands?.filter(c => c.outcome === 'fail') ?? [];
+                inheritedHealth =
+                    failing.length > 0 ?
+                        `${VERIFY_FAIL_PREFIX[healthFailClass(failing)]} ${describeHealthFailures(failing)} — already failing before this task`
+                        : `repo health: ${h.reason} — already failing before this task`;
+            }
         }
     }
     const inherited = inheritedHealth === undefined ? {} : { inheritedHealth };

package/package.json

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