@mjasnikovs/pi-task 0.42.3 → 0.42.5

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

@@ -16,8 +16,13 @@
  * the dedup ledger — a title covering the same command, or any of the same files,
  * means no second entry, checked-off ones included, which is what stops a repair
  * that failed from being re-spawned.
+ *
+ * A red TEST command is repaired only when a task's regression of it is on the
+ * debt ledger. A suite can also be red because a database is not up here, or
+ * 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';
 /** The failing check, and what its output named. */
 export interface HealthRed {
     command: string;
@@ -31,13 +36,23 @@ export interface HealthRedOwners {
     owners: string[];
 }
 /**
- * What a red health result is about. Null when the result records no failing
- * command (a legacy baseline, or a signal with no per-command detail) — there is
- * nothing a repair could be pinned to.
+ * What a red health result is about: its first failing 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.
  */
 export declare function healthRedSubject(health: HealthSignal & {
     output?: string;
-}, cwd: string, tracked: readonly string[] | null): HealthRed | null;
+}, cwd: string, tracked: readonly string[] | null, mayRepair?: (c: HealthCommandResult) => boolean): HealthRed | null;
+/**
+ * Is a red TEST command owed? True when an open debt records a task's regression
+ * of it — an accepted `test suite:` FAIL naming the command. An inherited-health
+ * debt does not count: every task in a run whose suite needs a missing database
+ * records one.
+ */
+export declare function suiteRegressionOwed(cmd: string, openDebts: readonly {
+    reason: string;
+    origin?: string;
+}[]): boolean;
 /**
  * The plan title, in one of two fixed shapes the parser below recovers:
  *   `repair src/a.ts, src/b.ts: \`bun run lint\` exits 1 (introduced by TASK_0033)`

package/dist/task/health-repair.js

@@ -1,4 +1,5 @@
 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. */
 const PATH_TOKEN_RE = /(?:[\w.@-]+[\\/])+[\w.@-]+\.\w+/g;
 function normalisePath(p) {
@@ -22,17 +23,17 @@ function resolveTracked(token, cwd, tracked) {
     return bySuffix.length === 1 ? bySuffix[0] : null;
 }
 /**
- * What a red health result is about. Null when the result records no failing
- * command (a legacy baseline, or a signal with no per-command detail) — there is
- * nothing a repair could be pinned to.
+ * What a red health result is about: its first failing 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.
  */
-export function healthRedSubject(health, cwd, tracked) {
-    const failing = (health.commands ?? []).find(c => c.outcome === 'fail');
+export function healthRedSubject(health, cwd, tracked, mayRepair = () => true) {
+    const failing = (health.commands ?? []).find(c => c.outcome === 'fail' && mayRepair(c));
     if (!failing)
         return null;
     const files = [];
     if (tracked) {
-        for (const m of (health.output ?? '').matchAll(PATH_TOKEN_RE)) {
+        for (const m of (failing.output ?? health.output ?? '').matchAll(PATH_TOKEN_RE)) {
             const rel = resolveTracked(m[0], cwd, tracked);
             if (rel !== null && !files.includes(rel))
                 files.push(rel);
@@ -40,6 +41,17 @@ export function healthRedSubject(health, cwd, tracked) {
     }
     return { command: failing.cmd, exitCode: failing.exitCode, files };
 }
+/**
+ * Is a red TEST command owed? True when an open debt records a task's regression
+ * of it — an accepted `test suite:` FAIL naming the command. An inherited-health
+ * debt does not count: every task in a run whose suite needs a missing database
+ * records one.
+ */
+export function suiteRegressionOwed(cmd, openDebts) {
+    return openDebts.some(d => d.origin !== 'inherited-health'
+        && failClassOfReason(d.reason) === 'test-suite'
+        && d.reason.includes(`\`${cmd}\``));
+}
 // ─── Plan entry ──────────────────────────────────────────────────────────────
 /**
  * The plan title, in one of two fixed shapes the parser below recovers:

package/dist/task/phases.js

@@ -673,6 +673,55 @@ export async function phaseResearch(deps, refined, rawPrompt = '') {
     }
     return sections.map(({ name, text }) => `${name}\n${text}`).join('\n\n');
 }
+/**
+ * Hold an answer to every guard. Each guard re-asks ONCE, and the answer that
+ * comes back faces every guard again: one that fixed a deferral by inventing an
+ * API is still caught. An answer that trips a guard it was already re-asked for,
+ * or a re-ask that produced no tagged answer, is surfaced as an unknown carrying
+ * that guard's reason. yolo.ts skips those, and a human sees them.
+ */
+async function guardAutoAnswer(deps, first, guards) {
+    const reasked = new Set();
+    let parsed = first;
+    while (parsed.kind === 'answered') {
+        const answer = parsed.text;
+        let tripped;
+        for (const g of guards) {
+            const prompt = g.reask(answer);
+            if (prompt !== null) {
+                tripped = { reason: g.reason, prompt };
+                break;
+            }
+        }
+        if (!tripped)
+            return parsed;
+        const surfaced = {
+            kind: 'unknown',
+            suggested: answer,
+            raw: parsed.raw,
+            reason: tripped.reason
+        };
+        if (reasked.has(tripped.reason)) {
+            deps.logDebug?.(`grill-auto: ${tripped.reason} survived its re-ask — surfacing to user`);
+            return surfaced;
+        }
+        reasked.add(tripped.reason);
+        let again = null;
+        try {
+            const text = await runPhaseChild(deps, 'grill-auto', 'read', tripped.prompt);
+            if (autoAnswerHasTag(text))
+                again = parseAutoAnswer(text);
+        }
+        catch (e) {
+            if (isFatalChildCause(e))
+                throw e;
+        }
+        if (again === null)
+            return surfaced;
+        parsed = again;
+    }
+    return parsed;
+}
 export async function phaseAutoAnswer(deps, refined, research, question) {
     const docsFocusedFn = deps.docsFocused ?? docsFocused;
     const fetchFocusedFn = deps.fetchFocused ?? fetchFocused;
@@ -724,84 +773,35 @@ export async function phaseAutoAnswer(deps, refined, research, question) {
             // otherwise a preamble line leaks out as the recommended answer.
             text = await runPhaseChild(deps, 'grill-auto', 'read', prependHint(GRILL_AUTO_FORMAT_HINT, basePrompt));
         }
-        let parsed = parseAutoAnswer(text);
-        // Anti-synthesis guard: the auto-answer invented
-        // `Bun.mkdirSync` while research's APIS section carried the correct list,
-        // and the invention was promoted into requirements + VERIFY. Deterministic
-        // verbatim-substring check: an API-shaped identifier in the answer that is
-        // absent from the research AND the question, in a namespace the research
-        // claims to cover, triggers ONE re-ask with the verified research lines
-        // injected. Still synthesizing after the re-ask ⇒ surface to the user as a
-        // recommendation instead of silently promoting it (costs time, never work).
-        if (parsed.kind === 'answered') {
-            const synth = findSynthesizedApis(parsed.text, question, research);
-            if (synth.length > 0) {
-                deps.logDebug?.('grill-auto: unverified API identifier(s) in answer — '
-                    + synth.map(f => f.identifier).join(', ')
-                    + ' — re-asking with the research API list injected');
-                let reasked = null;
-                try {
-                    const text2 = await runPhaseChild(deps, 'grill-auto', 'read', prependHint(synthesizedApiReaskHint(synth, research), basePrompt));
-                    if (autoAnswerHasTag(text2))
-                        reasked = parseAutoAnswer(text2);
-                }
-                catch (e) {
-                    if (isFatalChildCause(e))
-                        throw e;
-                    reasked = null;
+        const parsed = await guardAutoAnswer(deps, parseAutoAnswer(text), [
+            // Anti-synthesis: the auto-answer invented `Bun.mkdirSync` while
+            // research's APIS section carried the correct list, and the invention
+            // was promoted into requirements + VERIFY. An API-shaped identifier
+            // absent from the research AND the question, in a namespace the
+            // research claims to cover, is re-asked with the verified lines injected.
+            {
+                reason: 'api-synthesis',
+                reask: answer => {
+                    const synth = findSynthesizedApis(answer, question, research);
+                    if (synth.length === 0)
+                        return null;
+                    deps.logDebug?.('grill-auto: unverified API identifier(s) in answer — '
+                        + synth.map(f => f.identifier).join(', '));
+                    return prependHint(synthesizedApiReaskHint(synth, research), basePrompt);
                 }
-                if (reasked === null
-                    || (reasked.kind === 'answered'
-                        && findSynthesizedApis(reasked.text, question, research).length > 0)) {
-                    const still = reasked ?? parsed;
-                    const suggested = still.kind === 'answered' ? still.text : parsed.text;
-                    deps.logDebug?.('grill-auto: answer still carries an unverified API — surfacing to user');
-                    parsed = {
-                        kind: 'unknown',
-                        suggested,
-                        raw: still.raw,
-                        // Tagged so a call site can tell this producer from the other
-                        // two: the suggestion is PROVEN to name an unverified API, so
-                        // it may only be judged by a human (yolo.ts must not take it).
-                        reason: 'api-synthesis'
-                    };
-                }
-                else {
-                    parsed = reasked;
+            },
+            // Behind the prompt's GREEN-SUITE CHECK: promoting "flag it for the test
+            // owner" is how mx5-n TASK_0004 turned the suite red for the rest of the run.
+            {
+                reason: 'deferred-breakage',
+                reask: answer => {
+                    if (!defersBreakage(answer))
+                        return null;
+                    deps.logDebug?.('grill-auto: answer defers a breakage to a nonexistent owner');
+                    return prependHint(deferredBreakageReaskHint(answer), basePrompt);
                 }
             }
-        }
-        // Deterministic backstop behind the prompt's GREEN-SUITE CHECK: an answer
-        // that defers a breakage to "the test owner" gets ONE re-ask, and a second
-        // deferral is surfaced as an unsafe unknown — yolo.ts skips it, a human
-        // sees it. Promoting it is how mx5-n TASK_0004 turned the suite red for
-        // the rest of the run.
-        if (parsed.kind === 'answered' && defersBreakage(parsed.text)) {
-            deps.logDebug?.('grill-auto: answer defers a breakage to a nonexistent owner — re-asking once');
-            let reasked = null;
-            try {
-                const text2 = await runPhaseChild(deps, 'grill-auto', 'read', prependHint(deferredBreakageReaskHint(parsed.text), basePrompt));
-                if (autoAnswerHasTag(text2))
-                    reasked = parseAutoAnswer(text2);
-            }
-            catch (e) {
-                if (isFatalChildCause(e))
-                    throw e;
-                reasked = null;
-            }
-            if (reasked !== null && reasked.kind === 'answered' && !defersBreakage(reasked.text)) {
-                parsed = reasked;
-            }
-            else {
-                deps.logDebug?.('grill-auto: answer still defers the breakage — surfacing to user');
-                parsed = {
-                    kind: 'unknown',
-                    suggested: reasked?.kind === 'answered' ? reasked.text : parsed.text,
-                    raw: (reasked ?? parsed).raw,
-                    reason: 'deferred-breakage'
-                };
-            }
-        }
+        ]);
         // Surviving-unknown routing: an integration / build-wiring unknown whose
         // wrong guess is a structural landmine must NOT be silently auto-answered.
         // We first try to ground it from fetched docs (the enrichment fan-out

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.
@@ -15,20 +15,29 @@ export interface HealthCommandResult {
     outcome: 'pass' | 'fail' | 'skip';
     /** Real exit status on a `fail`; null when nothing conclusive ran. */
     exitCode: number | null;
+    /** 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;
 }
 export interface HealthOutcome {
-    /** true → every discovered static check passed, or there was nothing to run.
-     *  false → a discovered command actually ran and exited non-zero. */
+    /** true → every discovered check passed or could not run, or there was nothing
+     *  to run. false → a discovered command actually ran and exited non-zero. */
     ok: boolean;
-    /** Human-readable reason. On a fail, names the exact command and exit code. */
+    /** Human-readable reason. On a fail, names every failing command and its exit code. */
     reason: string;
     /** Which manifest drove discovery, or null when none was found. */
     ecosystem: string | null;
-    /** Every command that was REACHED, in run order. The run short-circuits on the
-     *  first failure, so commands after it are absent rather than passing. */
+    /** Every discovered command, in run order. A red one does not stop the run: a
+     *  command it skipped would be absent from both sides of the differential, which
+     *  then cannot see that command break. */
     commands: HealthCommandResult[];
     /**
-     * First lines of the failing command's combined stderr+stdout — captured so a
+     * First lines of the first failing command's combined stderr+stdout — captured so a
      * FAIL is explainable from artifacts alone. The exit code alone does not say
      * what happened: eslint exits 1 for findings and 2 when it could not run at
      * all (a missing config, say), so "`bun run lint` exited 2" is unreproducible
@@ -65,7 +74,8 @@ export declare function discoverHealthCommands(cwd: string): {
  * Every test-shaped script, not just the one literally named `test`: a project's
  * only browser-executing suite is often `test:ct`, and looking for `test` alone
  * never runs it. Plain `test` leads, then every `test:`/`test_`/`test-` name in
- * declaration order (Array#sort is stable).
+ * declaration order (Array#sort is stable). A watch-mode script is left out: it
+ * never exits, so all it can add is a timeout.
  */
 export declare function discoverTestCommands(cwd: string): {
     ecosystem: string | null;
@@ -80,7 +90,7 @@ export type HealthProgress = (command: string) => void;
  *  - No manifest / no static command  → ok (nothing can regress).
  *  - A command that CANNOT run (ENOENT / null exit / 127 inside the chain) → skipped,
  *    treated as an environment gap, not a fault.
- *  - A command that ran and exited non-zero → the first such failure is returned.
+ *  - A command that ran and exited non-zero → red. Every command still runs.
  *
  * This module owns DISCOVERY and its own output policy. Running a command and
  * deciding what its ending MEANS is `command-run.ts`'s — one statement of the
@@ -105,3 +115,5 @@ export declare function runRepoHealthCheck(cwd: string, opts?: {
      *  that will judge the result DIFFERENTIALLY may set this — see the header. */
     withTests?: boolean;
 }): Promise<HealthOutcome>;
+/** "`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,6 +125,17 @@ export function discoverHealthCommands(cwd) {
     }
     return { ecosystem: null, cmds: [] };
 }
+/**
+ * `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)?(?:=(?:true|1))?(?=\s|$)|(?:^|\s)watch(?=\s|$)/.test(body));
+}
 /**
  * The project's OWN test commands, in the order the run-end gate runs them. One
  * statement for both gates: final-gate.ts appends `build` to this list for the
@@ -134,12 +145,13 @@ export function discoverHealthCommands(cwd) {
  * Every test-shaped script, not just the one literally named `test`: a project's
  * only browser-executing suite is often `test:ct`, and looking for `test` alone
  * never runs it. Plain `test` leads, then every `test:`/`test_`/`test-` name in
- * declaration order (Array#sort is stable).
+ * declaration order (Array#sort is stable). A watch-mode script is left out: it
+ * never exits, so all it can add is a timeout.
  */
 export function discoverTestCommands(cwd) {
     if (existsSync(path.join(cwd, 'package.json'))) {
         const s = packageScripts(cwd);
-        const names = Object.keys(s).filter(n => n === 'test' || /^test[:_-]/.test(n));
+        const names = Object.keys(s).filter(n => (n === 'test' || /^test[:_-]/.test(n)) && !isWatchScript(n, s[n]));
         names.sort((a, b) => a === 'test' ? -1
             : b === 'test' ? 1
                 : 0);
@@ -178,7 +190,7 @@ function noCommandOutcome(ecosystem) {
  *  - No manifest / no static command  → ok (nothing can regress).
  *  - A command that CANNOT run (ENOENT / null exit / 127 inside the chain) → skipped,
  *    treated as an environment gap, not a fault.
- *  - A command that ran and exited non-zero → the first such failure is returned.
+ *  - A command that ran and exited non-zero → red. Every command still runs.
  *
  * This module owns DISCOVERY and its own output policy. Running a command and
  * deciding what its ending MEANS is `command-run.ts`'s — one statement of the
@@ -225,23 +237,39 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
         // ladder's `tail` keeps 400 characters, and that difference is real — a
         // truncated lint report is unactionable. So the run is classified, not
         // consumed: the verdict decides, the raw streams are what we show.
-        // `runtimeGap` only for a TEST command. The browser/runtime row was
-        // written for the gate's test commands and its pattern matches ordinary
-        // English, so on lint and typecheck a genuine report quoting "browsers are
-        // not installed" would skip the static check and certify the repo healthy.
-        const verdict = classifyCommandRun(r, [], { runtimeGap: test });
+        // `runtimeGap` and `emptySuite` only for a TEST command. Both rows read the
+        // command's output, and on lint and typecheck a genuine report quoting
+        // "browsers are not installed" would skip the static check and certify
+        // the repo healthy.
+        const verdict = classifyCommandRun(r, [], { runtimeGap: test, emptySuite: test });
+        const kind = test ? 'test' : 'static';
         if (verdict.outcome !== 'fail') {
             const passed = verdict.outcome === 'pass';
-            commands.push({ cmd, outcome: passed ? 'pass' : 'skip', exitCode: passed ? 0 : null });
+            commands.push({
+                cmd,
+                outcome: passed ? 'pass' : 'skip',
+                exitCode: passed ? 0 : null,
+                kind,
+                ...(verdict.outcome === 'gap' ? { gap: verdict.gap } : {})
+            });
             continue;
         }
-        commands.push({ cmd, outcome: 'fail', exitCode: verdict.status });
+        commands.push({
+            cmd,
+            outcome: 'fail',
+            exitCode: verdict.status,
+            kind,
+            output: captureHealthOutput(r.stdout, r.stderr)
+        });
+    }
+    const firstFail = commands.find(c => c.outcome === 'fail');
+    if (firstFail) {
         return {
             ok: false,
-            reason: `\`${cmd}\` exited ${verdict.status}`,
+            reason: describeHealthFailures(commands),
             ecosystem,
             commands,
-            output: captureHealthOutput(r.stdout, r.stderr)
+            output: firstFail.output ?? ''
         };
     }
     return {
@@ -252,3 +280,12 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
         output: ''
     };
 }
+/** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
+export function describeHealthFailures(commands) {
+    return commands
+        .filter(c => c.outcome === 'fail' || c.gap === 'empty-suite')
+        .map(c => c.outcome === 'fail' ?
+        `\`${c.cmd}\` exited ${c.exitCode}`
+        : `\`${c.cmd}\` found no tests to run`)
+        .join('; ');
+}

package/dist/task/run-context.d.ts

@@ -2,6 +2,7 @@ import type { SpawnFn } from '../shared/child-process.js';
 import { type EcosystemId } from '../workers/docs-ecosystems.js';
 import type { GateEvidence } from './gate-evidence.js';
 import { type OrientationResult } from './orientation.js';
+import { type HealthOutcome } from './repo-health-check.js';
 /**
  * What a verified command is FOR, and the only column that decides whether the
  * gate-evidence runner may execute it: `check` and `build` terminate on their own,
@@ -79,6 +80,8 @@ export declare class RunContext {
     private _toolingHash;
     private _evidence;
     private _evidenceQueue;
+    private _health;
+    private _healthQueue;
     constructor(opts: RunContextOptions);
     /** `git ls-files` for this run; '' outside a git tree (see file-inventory.ts). */
     inventory(): Promise<string>;
@@ -134,6 +137,17 @@ export declare class RunContext {
      */
     gateEvidenceFor(produce: EvidenceRunner): Promise<GateEvidence>;
     private freshEvidence;
+    /**
+     * The repo-health check with its suite, at most once per tree, on the same terms
+     * as {@link gateEvidenceFor}. A verify, the enforce baseline on the commit it
+     * just judged and the next task's checkpoint all measure one tree; each running
+     * the whole suite again is the cost this removes.
+     *
+     * Stored under the tree the check LEFT, not the one it found: a `--fix` lint
+     * moves the tree, and the result describes the fixed one.
+     */
+    healthFor(produce: () => Promise<HealthOutcome>): Promise<HealthOutcome>;
+    private freshHealth;
 }
 /** Open a run: every task inside it now shares one context. Nests — an inner
  *  bracket returns the outer run's context untouched. */

package/dist/task/run-context.js

@@ -19,8 +19,8 @@
  * run found it and is not re-read: a mid-run inventory refresh would hand two
  * tasks different orientation cores for the same question.
  *
- * TREE HASH is the other half, used by the gate-evidence cache; its one
- * implementation lives in tree-hash.ts.
+ * TREE HASH is the other half, used by the gate-evidence and repo-health caches;
+ * its one implementation lives in tree-hash.ts.
  */
 import { createHash } from 'node:crypto';
 import * as fsp from 'node:fs/promises';
@@ -90,6 +90,8 @@ export class RunContext {
     _toolingHash;
     _evidence;
     _evidenceQueue = Promise.resolve();
+    _health;
+    _healthQueue = Promise.resolve();
     constructor(opts) {
         this.cwd = opts.cwd;
         this.runId = opts.runId ?? newRunToken();
@@ -238,6 +240,31 @@ export class RunContext {
             this._evidence = { hash, value };
         return value;
     }
+    /**
+     * The repo-health check with its suite, at most once per tree, on the same terms
+     * as {@link gateEvidenceFor}. A verify, the enforce baseline on the commit it
+     * just judged and the next task's checkpoint all measure one tree; each running
+     * the whole suite again is the cost this removes.
+     *
+     * Stored under the tree the check LEFT, not the one it found: a `--fix` lint
+     * moves the tree, and the result describes the fixed one.
+     */
+    healthFor(produce) {
+        const next = this._healthQueue.then(() => this.freshHealth(produce));
+        this._healthQueue = next.catch(() => { });
+        return next;
+    }
+    async freshHealth(produce) {
+        const opts = this._signal ? { signal: this._signal } : {};
+        const found = await treeHash(this.cwd, opts);
+        if (found !== null && this._health?.hash === found)
+            return this._health.value;
+        const value = await produce();
+        const left = await treeHash(this.cwd, opts);
+        if (left !== null)
+            this._health = { hash: left, value };
+        return value;
+    }
 }
 /**
  * The context of the run that owns the session right now, set by the run bracket.

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

@@ -90,8 +90,12 @@ export type VerifyOutcome = VerifyPass | VerifyFail;
  * `static-checks` is the RUN-level twin of `repo-health`: final-gate.ts mints
  * `VERIFY_FAIL_PREFIX['static-checks']` for the same concept at the other
  * altitude, and `isStaticClass` answers true for both.
+ *
+ * `test-suite` is the same deterministic check when a TEST command regressed. It
+ * is its own class because a passing lint proves nothing about a suite: a static
+ * debt closes when the statics pass, and a lint fix cannot green a test.
  */
-export type VerifyFailClass = 'repo-health' | 'static-checks' | 'unobserved' | 'model-verdict' | 'harness-fault';
+export type VerifyFailClass = 'repo-health' | 'static-checks' | 'test-suite' | 'unobserved' | 'model-verdict' | 'harness-fault';
 /**
  * The prefix each class MINTS, stated once.
  *
@@ -117,6 +121,8 @@ export declare function verifyFailClass(o: {
 export declare function failClassOfReason(reason: string): VerifyFailClass | undefined;
 /** Does this class name a deterministic whole-repo static check, at either altitude? */
 export declare function isStaticClass(cls: VerifyFailClass | undefined): boolean;
+/** Does this class name the deterministic whole-repo check, suite included? */
+export declare function isHealthClass(cls: VerifyFailClass | undefined): boolean;
 /**
  * The delivered spec's TEXT, for the children that must read its prose verbatim.
  * The slicing itself lives in spec-model.ts beside the parser, so "the spec