@mjasnikovs/pi-task 0.42.2 → 0.42.4

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/parsers.d.ts

@@ -22,7 +22,7 @@ import type { ToolingClass } from './run-context.js';
  *     a recommendation instead of being taken silently.
  *   - 'threw' — the child failed; there is no recommendation at all.
  */
-export type AutoAnswerUnknownReason = 'model-unknown' | 'api-synthesis' | 'integration' | 'threw';
+export type AutoAnswerUnknownReason = 'model-unknown' | 'api-synthesis' | 'integration' | 'threw' | 'deferred-breakage';
 export type AutoAnswer = {
     kind: 'answered';
     text: string;

package/dist/task/phases.js

@@ -18,6 +18,7 @@ import { getConfig } from '../config/config.js';
 import { buildExternalContext, gatherExternalContext } from './external-context.js';
 import { currentRunContext } from './run-context.js';
 import { readableMentions } from './mentions.js';
+import { defersBreakage, deferredBreakageReaskHint } from './deferred-breakage.js';
 import { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, MAX_GRILL_QUESTIONS } from './prompts.js';
 import { appendGateRecord, readSection, readTaskFile, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
 import { extractSection } from './task-parsers.js';
@@ -672,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;
@@ -723,53 +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);
+        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);
                 }
-                catch (e) {
-                    if (isFatalChildCause(e))
-                        throw e;
-                    reasked = null;
-                }
-                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);
                 }
             }
-        }
+        ]);
         // 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/prompts.d.ts

@@ -36,6 +36,15 @@ declare const RESEARCH_APIS_PROMPT: (refined: string, filesMap: string | undefin
 declare const RESEARCH_CONTEXT_PROMPT: (refined: string) => string;
 declare const RESEARCH_TOOLING_PROMPT: (refined: string) => string;
 declare const GRILL_GEN_PROMPT: (refined: string, research: string, priorQA: string) => string;
+/**
+ * The first triage check. MEASURED (mx5-n TASK_0004, 2026-09-17): the auto-answer
+ * chose "flag the test breakage as a known issue for the test owner". No task owns
+ * a test, so the suite stayed red through four tasks, and the fifth was specced
+ * as "add three files, change nothing else, make the whole suite pass" — an
+ * unsatisfiable spec whose implementer looped until the runaway guard fired.
+ * Exported on its own so a harness can measure the prompt with and without it.
+ */
+export declare const GRILL_GREEN_SUITE_CHECK = "1. GREEN-SUITE CHECK \u2014 if an option would leave an existing test, lint, or build failing after this task (\"known issue\", \"for the test owner\", \"whoever revisits it\", \"a later step will fix it\"), that option is NOT available. Nobody downstream owns a breakage: every later task inherits a red suite it is told not to touch, and the run stalls there. A scope rule such as \"only create file X\" does NOT settle this \u2014 a test that asserts on X's output is part of X's change, so updating that test is in scope. If one option keeps the suite green, emit \"ANSWER: <that option>, and update <the test file> so the suite stays green\". If no offered option does, emit \"ANSWER: <the smallest change that keeps the suite green, naming the test file to update>\". Never answer with a deferral.";
 declare const GRILL_AUTO_ANSWER_PROMPT: (refined: string, research: string, question: string) => string;
 export declare const GRILL_AUTO_FORMAT_HINT: string;
 declare function composeRetryEmphasis(problem: string): string;

package/dist/task/prompts.js

@@ -208,6 +208,15 @@ ${research}
 
 Answers so far:
 ${priorQA.trim() || '(none yet)'}`;
+/**
+ * The first triage check. MEASURED (mx5-n TASK_0004, 2026-09-17): the auto-answer
+ * chose "flag the test breakage as a known issue for the test owner". No task owns
+ * a test, so the suite stayed red through four tasks, and the fifth was specced
+ * as "add three files, change nothing else, make the whole suite pass" — an
+ * unsatisfiable spec whose implementer looped until the runaway guard fired.
+ * Exported on its own so a harness can measure the prompt with and without it.
+ */
+export const GRILL_GREEN_SUITE_CHECK = `1. GREEN-SUITE CHECK — if an option would leave an existing test, lint, or build failing after this task ("known issue", "for the test owner", "whoever revisits it", "a later step will fix it"), that option is NOT available. Nobody downstream owns a breakage: every later task inherits a red suite it is told not to touch, and the run stalls there. A scope rule such as "only create file X" does NOT settle this — a test that asserts on X's output is part of X's change, so updating that test is in scope. If one option keeps the suite green, emit "ANSWER: <that option>, and update <the test file> so the suite stays green". If no offered option does, emit "ANSWER: <the smallest change that keeps the suite green, naming the test file to update>". Never answer with a deferral.`;
 const GRILL_AUTO_ANSWER_PROMPT = (refined, research, question) => `You are pre-answering a clarifying question for an AI coding task. You have the refined task and the research notes. You may use the read tool on files mentioned in the research (e.g. package.json) if it helps.
 
 Your job is to produce a recommended default. If the default is one the user would almost certainly accept without thinking, tag it ANSWER and skip the user. Otherwise tag it UNKNOWN. YOU MUST PROPOSE A DEFAULT — never refuse, never leave it empty.
@@ -223,11 +232,13 @@ API-GROUNDING RULE: never name a concrete API (\`Namespace.member\`, an imported
 
 TRIAGE — run these checks IN ORDER first. The REVERSIBILITY TEST below applies ONLY to a question that survives all checks as a genuine preference.
 
-1. ALREADY-DECIDED CHECK — scan the refined task and research for a value, shape, response body, schema, route, or requirement that ALREADY determines the answer. If one does, this is a fact, not a preference. Emit "ANSWER: <value taken from that source>". If your instinct or a "nicer" alternative contradicts that source, the SOURCE WINS — never override a stated contract with a preferred default. (E.g. a stated response shape { items, total, page, pageSize } already answers a pagination question — page/offset — you may NOT answer "cursor".)
+${GRILL_GREEN_SUITE_CHECK}
+
+2. ALREADY-DECIDED CHECK — scan the refined task and research for a value, shape, response body, schema, route, or requirement that ALREADY determines the answer. If one does, this is a fact, not a preference. Emit "ANSWER: <value taken from that source>". If your instinct or a "nicer" alternative contradicts that source, the SOURCE WINS — never override a stated contract with a preferred default. (E.g. a stated response shape { items, total, page, pageSize } already answers a pagination question — page/offset — you may NOT answer "cursor".)
 
-2. FUNCTIONAL-REQUIREMENT CHECK — if the question is whether to include or defer a package, config file, or setup that something THIS task configures needs in order to FUNCTION (a build plugin's engine or required peer dependency, an entry file the build reads, a runtime module an import resolves to), then a "minimize / keep it minimal / defer to the step that uses it" preference does NOT override that functional requirement. A tool you wire up this step must have its required pieces present this step or the build/step is broken. Emit "ANSWER: <include it now, because configuring X requires it>". Do not defer something the step's own configuration depends on.
+3. FUNCTIONAL-REQUIREMENT CHECK — if the question is whether to include or defer a package, config file, or setup that something THIS task configures needs in order to FUNCTION (a build plugin's engine or required peer dependency, an entry file the build reads, a runtime module an import resolves to), then a "minimize / keep it minimal / defer to the step that uses it" preference does NOT override that functional requirement. A tool you wire up this step must have its required pieces present this step or the build/step is broken. Emit "ANSWER: <include it now, because configuring X requires it>". Do not defer something the step's own configuration depends on.
 
-3. PREFERENCE — only if neither check fires (a genuine choice the sources do not determine), apply the REVERSIBILITY TEST.
+4. PREFERENCE — only if no check fires (a genuine choice the sources do not determine), apply the REVERSIBILITY TEST.
 
 REVERSIBILITY TEST:
   ANSWER: cheap to undo (output style, policy, report format, obvious scope, standard convention).

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

@@ -15,20 +15,26 @@ 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';
+    /** 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
@@ -56,6 +62,22 @@ export declare function discoverHealthCommands(cwd: string): {
     ecosystem: string | null;
     cmds: HealthCommand[];
 };
+/**
+ * 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
+ * integration half, and `runRepoHealthCheck` runs it under `withTests` for the
+ * per-task differential, so the two cannot drift apart.
+ *
+ * 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). 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;
+    cmds: HealthCommand[];
+};
 /** Progress hook: called with each command's label as it STARTS, so a caller can
  *  keep a live status line naming what is currently running. */
 export type HealthProgress = (command: string) => void;
@@ -65,7 +87,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
@@ -86,4 +108,9 @@ export declare function runRepoHealthCheck(cwd: string, opts?: {
     onCommand?: HealthProgress;
     /** The spawner. Injected so a verdict is testable without a real shell. */
     run?: CommandRunner;
+    /** Also run the project's test commands, after the statics. Only a caller
+     *  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

@@ -14,11 +14,18 @@
  * verify gate's `repo-health` FAIL (verify-work.ts), which reaches the
  * AUTOFIX / ACCEPT picker in verify-resolution.ts.
  *
- * Scope is deliberately STATIC ANALYSIS ONLY (lint / typecheck / clippy / vet), never
- * `test`, `build`, `run`, or anything that boots a server or needs a database. Those
- * depend on external services the verify prompt already carves out as an environment
- * gap, so running them here would blame code for a missing database. Static analysis
- * is hermetic: it needs no network, no service and no fixtures.
+ * Scope is STATIC ANALYSIS (lint / typecheck / clippy / vet) by default, never
+ * `build`, `run`, or anything that boots a server. Static analysis is hermetic: it
+ * needs no network, no service and no fixtures, so its absolute exit code decides.
+ *
+ * The TEST suite joins only under `withTests`, and only for the DIFFERENTIAL
+ * (health-baseline.ts). MEASURED (mx5-n TASK_0004, 2026-09-17): a task turned a
+ * green suite red, its spec called that a "known issue for the test owner", the
+ * model gate passed it, and four tasks later the run stalled on an unsatisfiable
+ * spec. A suite that needs a database fails the same way before and after the
+ * task, which the differential reads as pre-existing — so running it here does
+ * not blame code for a missing database, and DOES blame the task that broke a
+ * suite the baseline saw green.
  *
  * Absence is a PASS, two ways: (1) no recognised manifest at all (a pure-docs or
  * config-only repo has nothing that can regress); (2) a manifest with no static-check
@@ -118,6 +125,48 @@ export function discoverHealthCommands(cwd) {
     }
     return { ecosystem: null, cmds: [] };
 }
+/** `test:watch`, `jest --watchAll`, `vitest watch`, `bun test --watch`. */
+function isWatchScript(name, body) {
+    return (/watch/i.test(name) || /(?:^|\s)--watch(?:All)?(?=[\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
+ * integration half, and `runRepoHealthCheck` runs it under `withTests` for the
+ * per-task differential, so the two cannot drift apart.
+ *
+ * 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). 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)) && !isWatchScript(n, s[n]));
+        names.sort((a, b) => a === 'test' ? -1
+            : b === 'test' ? 1
+                : 0);
+        return { ecosystem: 'package.json', cmds: names.map(n => ['bun', ['run', n]]) };
+    }
+    if (existsSync(path.join(cwd, 'Makefile'))) {
+        return {
+            ecosystem: 'Makefile',
+            cmds: makeHasTarget(cwd, 'test') ? [['make', ['test']]] : []
+        };
+    }
+    if (existsSync(path.join(cwd, 'Cargo.toml'))) {
+        return { ecosystem: 'Cargo.toml', cmds: [['cargo', ['test', '--quiet']]] };
+    }
+    if (existsSync(path.join(cwd, 'go.mod'))) {
+        return { ecosystem: 'go.mod', cmds: [['go', ['test', './...']]] };
+    }
+    if (existsSync(path.join(cwd, 'pyproject.toml'))) {
+        return { ecosystem: 'pyproject.toml', cmds: [['pytest', ['-q']]] };
+    }
+    return { ecosystem: null, cmds: [] };
+}
 /** The nothing-to-run outcome, shared by both runners. */
 function noCommandOutcome(ecosystem) {
     return {
@@ -134,7 +183,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
@@ -150,12 +199,18 @@ function noCommandOutcome(ecosystem) {
  * widget has just been cleared.
  */
 export async function runRepoHealthCheck(cwd, opts = {}) {
-    const { ecosystem, cmds } = discoverHealthCommands(cwd);
+    const statics = discoverHealthCommands(cwd);
+    const tests = opts.withTests ? discoverTestCommands(cwd) : { ecosystem: null, cmds: [] };
+    const ecosystem = statics.ecosystem ?? tests.ecosystem;
+    const cmds = [
+        ...statics.cmds.map(([bin, args]) => ({ bin, args, test: false })),
+        ...tests.cmds.map(([bin, args]) => ({ bin, args, test: true }))
+    ];
     if (!ecosystem || cmds.length === 0)
         return noCommandOutcome(ecosystem);
     const run = opts.run ?? spawnCommand;
     const commands = [];
-    for (const [bin, args] of cmds) {
+    for (const { bin, args, test } of cmds) {
         const cmd = `${bin} ${args.join(' ')}`;
         opts.onCommand?.(cmd);
         // Runner resolution: a PATH-stripped environment must not
@@ -175,31 +230,52 @@ 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: false` — this ladder is NARROWER than the gate's. The
-        // browser/runtime row was written for the gate's TEST commands; here the
-        // commands are lint and typecheck, and its pattern matches ordinary
-        // English, so a genuine report quoting "browsers are not installed" would
-        // skip the static check and certify the repo healthy.
-        const verdict = classifyCommandRun(r, [], { runtimeGap: false });
+        // `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
+            });
             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 {
         ok: true,
-        reason: `${ecosystem}: static checks passed`,
+        reason: `${ecosystem}: static checks${tests.cmds.length > 0 ? ' and tests' : ''} passed`,
         ecosystem,
         commands,
         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')
+        .map(c => `\`${c.cmd}\` exited ${c.exitCode}`)
+        .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