@mjasnikovs/pi-task 0.42.3 → 0.42.4

package/dist/task/accept-debt.d.ts

@@ -155,11 +155,12 @@ export declare function writeAcceptDebts(cwd: string, debts: AcceptDebt[]): Prom
 /** The debts nothing has closed yet — the only ones a re-check may read. */
 export declare function readOpenAcceptDebts(cwd: string): Promise<AcceptDebt[]>;
 /**
- * Close every open static-class debt that names `command`, stamping the task
+ * Close every open health-class debt that names `command`, stamping the task
  * whose verified work made that check pass again. Returns the debts closed.
  * A reason that quotes the command is the whole match: the health-check reason
  * (`repo health: \`bun run lint\` exited 1`) and its inherited form both do,
- * and nothing else in the ledger quotes a health command. Best-effort.
+ * and nothing else in the ledger quotes a health command. A suite debt closes
+ * here too: the repair verified clean, and that check runs the suite. Best-effort.
  */
 export declare function closeHealthDebts(cwd: string, command: string, resolvedBy: string): Promise<AcceptDebt[]>;
 /**

package/dist/task/accept-debt.js

@@ -35,7 +35,7 @@ import { existsSync } from 'node:fs';
 import * as path from 'node:path';
 import * as fsp from 'node:fs/promises';
 import { runVerifyCommandLine, spawnCommand } from './command-run.js';
-import { failClassOfReason, isStaticClass } from './verify-work.js';
+import { failClassOfReason, isHealthClass, isStaticClass } from './verify-work.js';
 import { taskThatIntroduced } from './task-provenance.js';
 import { makeLedger } from './ledger.js';
 import { parseVerifyBlockStrict } from './spec-validation.js';
@@ -251,18 +251,19 @@ export async function readOpenAcceptDebts(cwd) {
     return (await readAcceptDebts(cwd)).filter(d => d.resolvedBy === undefined);
 }
 /**
- * Close every open static-class debt that names `command`, stamping the task
+ * Close every open health-class debt that names `command`, stamping the task
  * whose verified work made that check pass again. Returns the debts closed.
  * A reason that quotes the command is the whole match: the health-check reason
  * (`repo health: \`bun run lint\` exited 1`) and its inherited form both do,
- * and nothing else in the ledger quotes a health command. Best-effort.
+ * and nothing else in the ledger quotes a health command. A suite debt closes
+ * here too: the repair verified clean, and that check runs the suite. Best-effort.
  */
 export async function closeHealthDebts(cwd, command, resolvedBy) {
     try {
         const all = await readAcceptDebts(cwd);
         const quoted = `\`${command}\``;
         const closing = all.filter(d => d.resolvedBy === undefined
-            && isStaticClassDebt(d.reason)
+            && isHealthClass(failClassOfReason(d.reason))
             && d.reason.includes(quoted));
         if (closing.length === 0)
             return [];

package/dist/task/auto-orchestrator.js

@@ -20,7 +20,7 @@ import { GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT } from './prompts.js';
 import { allocateAutoId, buildAutoBody, parseDecomposeList, parseCoverageVerdict, UNNAMED_COVERAGE_GAP, parseTaskList, planKeyAt, checkOffTask, stampTaskInProgress, beginTaskAttempt, recordTaskEnd, insertTaskAfter, insertTaskBefore, findResumableAutoDetailed } from './auto-io.js';
 import { decideResume, UNATTENDED_STATES } from './resume-gap.js';
 import { ENTRY_ATTEMPT_BUDGET } from './gate-resolution.js';
-import { recordDebt } from './accept-debt.js';
+import { readOpenAcceptDebts, recordDebt } from './accept-debt.js';
 import { drainRepairQueue, mergeRepairCandidates, planHasRepairFor, parseRepairTitleFile, buildRepairTitle, buildRepairScopeFence, extractFailingCommand } from './root-cause-repair.js';
 import { writeTaskFile, readTaskFile, readSection, updateTaskFrontMatter, taskFilePath } from './task-io.js';
 // Re-exported as well as used: the @-mention helpers moved to their own module so
@@ -38,7 +38,7 @@ import { getParentContextWindow } from './context-usage.js';
 import { ChildStatus, runPlanningChild, statusCallbacks } from './child-status.js';
 import { buildGateDeps, collectTreeChanges } from './gate-deps.js';
 import { runGatesForTask } from './task-gates.js';
-import { buildHealthRepairFence, buildHealthRepairTitle, healthRedSubject, parseHealthRepairTitle, planCoversHealthRed } from './health-repair.js';
+import { buildHealthRepairFence, buildHealthRepairTitle, healthRedSubject, suiteRegressionOwed, parseHealthRepairTitle, planCoversHealthRed } from './health-repair.js';
 import { HEALTH_BASELINE_SECTION, parseHealthBaseline } from './health-baseline.js';
 import { runFinalGateStage } from './run-final-gate.js';
 import { gitUnmergedPaths, gitStashRef } from './auto-commit.js';
@@ -392,7 +392,8 @@ async function schedulePendingRepairs(cwd, id, afterIndex, ctx, deps) {
  */
 async function spliceHealthRepair(cwd, id, next, entries, health, ctx, deps) {
     try {
-        const red = healthRedSubject(health, cwd, (await deps.repoFiles?.(cwd)) ?? null);
+        const debts = await readOpenAcceptDebts(cwd);
+        const red = healthRedSubject(health, cwd, (await deps.repoFiles?.(cwd)) ?? null, c => c.kind !== 'test' || suiteRegressionOwed(c.cmd, debts));
         if (!red)
             return false;
         if (planCoversHealthRed(entries.map(e => e.title), red))
@@ -609,8 +610,9 @@ export async function elicitClarifications(ctx, cwd, deps, oriented) {
         }
         // YOLO: take the recommended option (index 0 / the green card) without ever
         // building the prompt. Clarify has no anti-synthesis channel — it runs before
-        // any research — so the only step-aside here is a question that carries no
-        // recommendation to take; that one is skipped rather than guessed.
+        // any research — so the step-asides here are a question with no
+        // recommendation to take, and one whose every option defers a breakage the
+        // triage just refused; each is skipped rather than guessed.
         const outcome = await settleQuestion({
             ui,
             transcript,
@@ -1366,7 +1368,7 @@ export async function runAutoLoop(ctx, cwd, id, deps) {
                 notifyRun(active, `${id}: checkpointed uncommitted work before "${next.title}".`, 'info');
             }
             // REPO-HEALTH BASELINE, taken here because the checkpoint above just made
-            // the tree clean: what the project's own statics say now is what this task
+            // the tree clean: what the project's own checks say now is what this task
             // INHERITED, and the verify gate attributes a red check against it instead
             // of failing the task for a sibling's defect (health-baseline.ts). The
             // inner task file does not exist yet, so the result is handed to the

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

@@ -109,8 +109,14 @@ export declare const ENV_GAP_OUTPUT_RE: RegExp;
  * `gapPatterns`, which is why that parameter exists rather than a boolean.
  */
 export declare const INFRA_GAP_OUTPUT_RE: RegExp;
+/**
+ * A test runner that found no tests to run: bun, jest, vitest, mocha and pytest
+ * each exit non-zero on it. A suite that ran nothing observed nothing, which is the
+ * contract's definition of a gap. Test commands only (see `emptySuite`).
+ */
+export declare const EMPTY_SUITE_OUTPUT_RE: RegExp;
 /** Which way a command failed to tell us anything. */
-export type CommandGapId = 'spawn-failed' | 'killed' | 'command-not-found' | 'missing-runtime' | 'infrastructure';
+export type CommandGapId = 'spawn-failed' | 'killed' | 'command-not-found' | 'missing-runtime' | 'infrastructure' | 'empty-suite';
 export type CommandVerdict = 
 /** Nothing was observed. Never fails a gate, never closes a debt. */
 {
@@ -145,6 +151,11 @@ export interface ClassifyOptions {
      * and tell the gate the repo is healthy.
      */
     runtimeGap?: boolean;
+    /**
+     * May this command's output claim it found NO TESTS? False by default: the
+     * wording is only a gap when a test runner printed it.
+     */
+    emptySuite?: boolean;
 }
 /**
  * Decide what one finished command proved. Pure — no spawning, no filesystem, no

package/dist/task/command-run.js

@@ -233,6 +233,12 @@ export const ENV_GAP_OUTPUT_RE = /Executable doesn't exist|playwright install|br
  * `gapPatterns`, which is why that parameter exists rather than a boolean.
  */
 export const INFRA_GAP_OUTPUT_RE = /ECONNREFUSED|connection refused|ENOTFOUND|EAI_AGAIN|is the server running|could not connect|cannot connect to the docker daemon|connect: connection|no such host/i;
+/**
+ * A test runner that found no tests to run: bun, jest, vitest, mocha and pytest
+ * each exit non-zero on it. A suite that ran nothing observed nothing, which is the
+ * contract's definition of a gap. Test commands only (see `emptySuite`).
+ */
+export const EMPTY_SUITE_OUTPUT_RE = /\b0 test files matching\b|\bNo tests found\b|\bNo test files found\b|\bno tests ran\b|\bcollected 0 items\b/i;
 /**
  * The gap ladder, in order. FIRST MATCH WINS.
  *
@@ -268,6 +274,11 @@ const GAP_RULES = [
         id: 'infrastructure',
         detail: () => 'external infrastructure unreachable',
         applies: (_run, output, gapPatterns) => gapPatterns.some(re => re.test(output))
+    },
+    {
+        id: 'empty-suite',
+        detail: () => 'no tests found',
+        applies: (_run, output) => EMPTY_SUITE_OUTPUT_RE.test(output)
     }
 ];
 /** Last ~`limit` chars of the command's combined output, one line, for the reason. */
@@ -296,6 +307,8 @@ export function classifyCommandRun(run, gapPatterns = [], opts = {}) {
     for (const rule of GAP_RULES) {
         if (rule.id === 'missing-runtime' && !runtimeGap)
             continue;
+        if (rule.id === 'empty-suite' && opts.emptySuite !== true)
+            continue;
         if (rule.applies(run, output, gapPatterns)) {
             return { outcome: 'gap', gap: rule.id, detail: rule.detail(run) };
         }

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

@@ -1,3 +1,23 @@
+/**
+ * Does an auto-answer hand a breakage to someone who does not exist?
+ *
+ * MEASURED (mx5-n TASK_0004, 2026-09-17): "flag the test/migrate.test.ts breakage
+ * as a known issue for the test owner". Nothing in a /task-auto run owns a test:
+ * the answer was stamped `(auto)`, verify passed the task with the suite red, and
+ * four tasks later an unsatisfiable spec looped until the runaway guard fired.
+ *
+ * This is the deterministic backstop behind the prompt's GREEN-SUITE CHECK: a
+ * model that ignores the rule still cannot promote a deferral into a decision.
+ * 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.
+ */
 export declare function defersBreakage(answer: string): boolean;
 /** The one re-ask a deferring answer gets before it is surfaced instead of promoted. */
 export declare function deferredBreakageReaskHint(answer: string): string;

package/dist/task/deferred-breakage.js

@@ -10,33 +10,95 @@
  * model that ignores the rule still cannot promote a deferral into a decision.
  * 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.
  */
-const DEFERRAL_PHRASES = [
-    /\bknown[- ]issue\b/i,
-    /\b(?:test|suite|file|module)[- ]owner\b/i,
-    /\bwhoever\s+(?:owns|revisits|maintains|touches)\b/i,
-    /\bowned by\s+(?:whoever|the\s+\w+\s+owner|a\s+later\s+(?:step|task))/i,
-    /\b(?:a|the)\s+later\s+(?:step|task)\s+(?:will|should|can|to)\s+(?:fix|revisit|update|repair|address)/i,
-    /\bleave\s+(?:the\s+)?(?:test|tests|suite|failure|breakage)\s+(?:failing|red|broken|as[- ]is)\b/i,
-    /\baccept(?:ing)?\s+(?:that\s+)?.{0,60}?\b(?:test|tests|suite|assertions?|lint|build)\b.{0,80}?\b(?:fail|failing|red|broken)\b/i,
-    /\bflag(?:ged|ging)?\s+(?:it\s+|this\s+|the\s+\S+\s+)?(?:as\s+)?(?:a\s+)?(?:known|for\s+(?:the|a|whoever))/i,
-    /\b(?:owned|as the owned|as a)\s+follow-?up\b/i,
-    /\bleft\s+for\s+(?:whoever|the\s+\w+\s+owner)\b/i,
-    /\bownership\s+belongs\s+to\b/i
+/** 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/;
+const PHRASES = [
+    { re: /\b(?:test|suite)[- ]owners?\b/i, needs: 'alone' },
+    {
+        re: /\bflag(?:s|ged|ging)?\b.*?\b(?:as\s+(?:an?\s+|the\s+)?(?:known|owned)\b|for\s+(?:whoever|later|a\s+later)\b)/i,
+        needs: 'alone'
+    },
+    {
+        re: /\bleav(?:e|es|ing)\b.*?\b(?:tests?|suites?|assertions?|lint|build|checks?|ci)\b.*?\b(?:failing|red|broken|as[- ]is)\b/i,
+        needs: 'alone'
+    },
+    {
+        re: /\bskip(?:s|ping)?\s+(?:updating|fixing|adjusting|changing|touching)\b.*?\b(?:tests?|suites?|assertions?)\b/i,
+        needs: 'alone'
+    },
+    { re: /\baccept(?:s|ed|ing)?\b.*?\b(?:fail\w*|red|broken)\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' },
+    {
+        re: /\b(?:a|the|another|some)\s+(?:later|future|subsequent|separate)\s+(?:step|task|change|pr)\b/i,
+        needs: 'check'
+    },
+    { re: /\bdefer(?:s|red|ring)?\b/i, needs: 'check' },
+    { re: /\bout\s+of\s+scope\b/i, needs: 'check' },
+    {
+        re: /\b(?:that|this|which|it|they|those)\s+(?:is|are|remains?)\s+out\s+of\s+scope\b/i,
+        needs: 'breakage'
+    }
 ];
-/** "do NOT defer", "not a deferral to a test owner", "rather than flag it" — the
- *  phrase is named to reject it. MEASURED: a treatment answer did exactly that. */
-const NEGATION_BEFORE = /\b(?:not|never|no|don't|do not|rather than|instead of|isn't|is not|without)\b[^.;]{0,40}$/i;
+function aboutACheck(text) {
+    return TEST_NOUN.test(text) || (BUILD_NOUN.test(text) && FAILURE.test(text));
+}
+/**
+ * Parenthetical asides go, and a code span keeps its words but loses the
+ * punctuation that would split a clause in two: `toEqual([{filename: X}])` is
+ * one token of the sentence around it, not three clauses.
+ */
+function prose(answer) {
+    let text = answer.replace(/`([^`]*)`/g, (_m, code) => code.replace(/[,;:()[\]{}]/g, ' '));
+    let before;
+    do {
+        before = text;
+        text = text.replace(/\([^()]*\)/g, ' ');
+    } while (text !== before);
+    return text;
+}
+function clauses(sentence) {
+    return sentence.split(CLAUSE_BOUNDARY).filter(c => c.trim().length > 0);
+}
 export function defersBreakage(answer) {
-    return DEFERRAL_PHRASES.some(re => {
-        const m = new RegExp(re.source, re.flags + (re.flags.includes('g') ? '' : 'g'));
-        for (const hit of answer.matchAll(m)) {
-            const before = answer.slice(Math.max(0, hit.index - 60), hit.index);
-            if (!NEGATION_BEFORE.test(before))
+    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;
+            }
         }
-        return false;
-    });
+    }
+    return false;
 }
 /** The one re-ask a deferring answer gets before it is surfaced instead of promoted. */
 export function deferredBreakageReaskHint(answer) {

package/dist/task/gate-deps.js

@@ -537,7 +537,10 @@ export async function healthBaselineFor(cwd, taskId, signal) {
             return stored;
         const fresh = await lazyHealthBaseline({
             git: makeGit(cwd, signal),
-            runHealthIn: dir => runRepoHealthCheck(dir, { signal, withTests: true })
+            // Statics only. The worktree has none of the tree's ignored files (the
+            // installed dependencies, a `.env`), so its suite fails for that, and a
+            // red recorded here would excuse the real regression it matches.
+            runHealthIn: dir => runRepoHealthCheck(dir, { signal })
         });
         if (fresh) {
             await setTaskSection(cwd, taskId, HEALTH_BASELINE_SECTION, formatHealthBaseline(fresh)).catch(() => { });
@@ -720,7 +723,31 @@ export function buildGateDeps(params) {
         await git(cwd2, ['checkout', '--', '.', EXCLUDE_TASKS_DIR], signal);
         await git(cwd2, ['clean', '-fd', '-e', '.pi-tasks'], signal);
     };
-    // The project's own statics, under a live loader naming the running command.
+    const untrackedFiles = async (cwd2) => {
+        const r = await git(cwd2, ['ls-files', '--others', '--exclude-standard', '-z', '--', '.', EXCLUDE_TASKS_DIR], signal);
+        return r.exitCode === 0 ? new Set(r.stdout.split('\u0000').filter(f => f.length > 0)) : null;
+    };
+    // 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.
+    const gateHealth = (cwd2, onCommand) => currentRunContext(cwd2).healthFor(async () => {
+        const before = await untrackedFiles(cwd2);
+        try {
+            return await runRepoHealthCheck(cwd2, { signal, withTests: true, onCommand });
+        }
+        finally {
+            const after = before ? await untrackedFiles(cwd2) : null;
+            for (const rel of after ?? []) {
+                if (!before?.has(rel)) {
+                    await fsp
+                        .rm(path.join(cwd2, rel), { recursive: true, force: true })
+                        .catch(() => { });
+                }
+            }
+        }
+    });
+    // The project's own checks, under a live loader naming the running command.
     // Each run is as long as that command, and a gate step that long with no widget
     // is indistinguishable from a hang. Shared by the enforce pre-commit gate (a
     // baseline before the edit pass, a differential after it) and by the
@@ -737,12 +764,8 @@ export function buildGateDeps(params) {
             startedAt,
             lastLine: running ? `repo health · ${running}` : 'repo health'
         }));
-        return runRepoHealthCheck(cwd2, {
-            signal,
-            withTests: true,
-            onCommand: c => {
-                running = c;
-            }
+        return gateHealth(cwd2, c => {
+            running = c;
         }).finally(stop);
     };
     // Adapter onto the shared gate-child runner (gate-child.ts). What survives
@@ -946,12 +969,8 @@ export function buildGateDeps(params) {
                 // progress hook here would be uncancellable and mute for reasons
                 // unrelated to the thing under test. The arm's only difference is
                 // the LOADER, above.
-                repoHealth: () => runRepoHealthCheck(cwd2, {
-                    signal,
-                    withTests: true,
-                    onCommand: c => {
-                        stageLine = `repo health · ${c}`;
-                    }
+                repoHealth: () => gateHealth(cwd2, c => {
+                    stageLine = `repo health · ${c}`;
                 }),
                 // What those checks said before the task started, so a red one
                 // is attributed rather than absolutely failed. Read only when

package/dist/task/gate-resolution.js

@@ -11,6 +11,7 @@ const REATTEMPTABLE_BUDGET = 3;
 export const AUTOFIX_BUDGET = {
     'repo-health': REATTEMPTABLE_BUDGET,
     'static-checks': REATTEMPTABLE_BUDGET,
+    'test-suite': REATTEMPTABLE_BUDGET,
     'model-verdict': REATTEMPTABLE_BUDGET,
     unobserved: 0,
     'harness-fault': 0

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

@@ -38,7 +38,14 @@ export type HealthDelta = 'clean' | 'regressed' | 'pre-existing';
  * default the enforce site used to carry.
  */
 export declare function classifyHealthDelta(baseline: HealthSignal | null, after: HealthSignal): HealthDelta;
-/** The failing commands, as prompt/trail lines naming the exit code. */
+/** 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[];
+/**
+ * The failing commands, as prompt/trail lines naming the exit code. A test
+ * runner exits 1 for one failing test or for fifty, so for a suite the line
+ * claims only the exit code: which tests fail was not compared.
+ */
 export declare function inheritedHealthFindings(after: HealthSignal): string[];
 export declare const HEALTH_BASELINE_SECTION = "health baseline";
 /**
@@ -46,9 +53,9 @@ export declare const HEALTH_BASELINE_SECTION = "health baseline";
  * grammar: this round-trips through a committed file that a later run parses, and
  * a second grammar is a second thing to drift.
  *
- * The captured `output` is dropped — up to 40 lines of a linter's report, in a
- * file committed with every task, for a field the differential never reads. The
- * live run's own trail already carries it.
+ * The captured output is dropped, the outcome's and each command's — up to 40
+ * lines of a linter's report, in a file committed with every task, for a field the
+ * differential never reads. The live run's own trail already carries it.
  */
 export declare function formatHealthBaseline(b: HealthBaseline): string;
 /** Parse a `## health baseline` section back. Null on anything unreadable — an

package/dist/task/health-baseline.js

@@ -52,13 +52,24 @@ export function classifyHealthDelta(baseline, after) {
     const detailed = now.length > 0 && (baseline.ok || before.length > 0);
     if (!detailed)
         return baseline.ok ? 'regressed' : 'pre-existing';
-    const key = (c) => JSON.stringify([c.cmd, c.exitCode]);
-    const wasFailing = new Set(before.map(key));
-    return now.every(c => wasFailing.has(key(c))) ? 'pre-existing' : 'regressed';
+    return regressedCommands(baseline, after).length > 0 ? 'regressed' : 'pre-existing';
 }
-/** The failing commands, as prompt/trail lines naming the exit code. */
+const failureKey = (c) => JSON.stringify([c.cmd, c.exitCode]);
+/** 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)));
+}
+/**
+ * The failing commands, as prompt/trail lines naming the exit code. A test
+ * runner exits 1 for one failing test or for fifty, so for a suite the line
+ * claims only the exit code: which tests fail was not compared.
+ */
 export function inheritedHealthFindings(after) {
-    return failures(after).map(c => `\`${c.cmd}\` exits ${c.exitCode} (and did before this task)`);
+    return failures(after).map(c => c.kind === 'test' ?
+        `\`${c.cmd}\` exits ${c.exitCode}, as it did before this task — the same exit code, not proof the same tests fail`
+        : `\`${c.cmd}\` exits ${c.exitCode} (and did before this task)`);
 }
 // ─── The task-file section ───────────────────────────────────────────────────
 export const HEALTH_BASELINE_SECTION = 'health baseline';
@@ -67,12 +78,13 @@ export const HEALTH_BASELINE_SECTION = 'health baseline';
  * grammar: this round-trips through a committed file that a later run parses, and
  * a second grammar is a second thing to drift.
  *
- * The captured `output` is dropped — up to 40 lines of a linter's report, in a
- * file committed with every task, for a field the differential never reads. The
- * live run's own trail already carries it.
+ * The captured output is dropped, the outcome's and each command's — up to 40
+ * lines of a linter's report, in a file committed with every task, for a field the
+ * differential never reads. The live run's own trail already carries it.
  */
 export function formatHealthBaseline(b) {
-    const { output: _output, ...outcome } = b.outcome;
+    const { output: _output, commands, ...rest } = b.outcome;
+    const outcome = { ...rest, commands: commands.map(({ output: _o, ...c }) => c) };
     return ['```json', JSON.stringify({ ...b, outcome }, null, 2), '```'].join('\n');
 }
 /** Parse a `## health baseline` section back. Null on anything unreadable — an

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

@@ -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
@@ -65,7 +71,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 +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
@@ -105,3 +112,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,10 @@ 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
@@ -134,12 +138,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 +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
@@ -225,23 +230,38 @@ 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
+            });
             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 +272,10 @@ 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')
+        .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

package/dist/task/verify-work.js

@@ -42,7 +42,8 @@ import { buildEnvNotesBlock, ENV_NOTE_EMIT_INSTRUCTION, extractEnvNotes } from '
 import { buildContractsVerifyBlock } from './contracts.js';
 import { findSkipEscapes, skipEscapeVerifyFindings } from './skip-escape.js';
 import { crossTaskDeletionVerifyFindings } from './task-provenance.js';
-import { classifyHealthDelta, inheritedHealthFindings } from './health-baseline.js';
+import { classifyHealthDelta, inheritedHealthFindings, regressedCommands } from './health-baseline.js';
+import { describeHealthFailures } from './repo-health-check.js';
 import { parseSpec, sliceSpecSection } from './spec-model.js';
 import { qaKindsFromRecord } from './qa-transcript.js';
 import { annotateConstraints, anyBinding, renderConstraintPolicy } from './constraint-policy.js';
@@ -72,6 +73,7 @@ const VERIFY_TOOLS = 'read,bash';
 export const VERIFY_FAIL_PREFIX = {
     'repo-health': 'repo health:',
     'static-checks': 'static checks:',
+    'test-suite': 'test suite:',
     unobserved: 'work unobserved:',
     'model-verdict': 'work did not verify:',
     'harness-fault': 'verification pass could not run:'
@@ -103,6 +105,14 @@ export function failClassOfReason(reason) {
 export function isStaticClass(cls) {
     return cls === 'repo-health' || cls === 'static-checks';
 }
+/** The class a red health result is minted under: the suite's when any test is red. */
+function healthFailClass(failing) {
+    return failing.some(c => c.kind === 'test') ? 'test-suite' : 'repo-health';
+}
+/** Does this class name the deterministic whole-repo check, suite included? */
+export function isHealthClass(cls) {
+    return isStaticClass(cls) || cls === 'test-suite';
+}
 /**
  * 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
@@ -182,8 +192,8 @@ const PROBE_ADAPTERS = [
         ]
     }),
     /**
-     * PRE-EXISTING repo health (see health-baseline.ts): static checks that were
-     * ALREADY failing, the same way, before this task started. They used to be an
+     * PRE-EXISTING repo health (see health-baseline.ts): checks that were ALREADY
+     * failing, with the same exit code, before this task started. They used to be an
      * absolute FAIL that short-circuited the whole pass, so the task answered for
      * a sibling's defect and its own probe findings were never computed. As a row
      * they are stated to the child instead: judge this task's work, and do not
@@ -197,7 +207,7 @@ const PROBE_ADAPTERS = [
         ruleId: '4h',
         block: findings => [
             'INHERITED REPO-HEALTH NOTICE (deterministic, computed by the orchestrator by',
-            "re-running the project's own static checks and comparing them against the",
+            "re-running the project's own checks and comparing their exit codes against the",
             'baseline taken before this task started): these checks were ALREADY failing,',
             'with the same exit code, before any of this work existed:',
             ...findings.map(f => `- ${f}`),
@@ -208,13 +218,16 @@ const PROBE_ADAPTERS = [
         ],
         rule: [
             "4h. AN INHERITED RED CHECK IS NOT THIS TASK'S FAIL, AND NOT ITS PROOF — when the",
-            '   INHERITED REPO-HEALTH NOTICE above names a check, that check failed identically',
+            '   INHERITED REPO-HEALTH NOTICE above names a check, that check exited the same way',
             '   before this task ran. Do NOT fail this work for it: the defect belongs to',
             '   whatever put it there, it is recorded as durable debt, and the run-end gate',
             '   re-checks it. Do NOT lean on it either — a command that was already exiting',
             "   non-zero tells you nothing about this task's behavior, so verify that behavior",
             '   another way. A check that is failing DIFFERENTLY, or one absent from the notice,',
-            "   is this task's to answer for in the ordinary way."
+            "   is this task's to answer for in the ordinary way. A TEST command is the",
+            '   exception to the exit code: it exits the same way for one failing test or',
+            "   fifty. Run it, and a test that fails because of THIS work is this task's FAIL,",
+            '   whatever the spec says about it.'
         ]
     }),
     /**
@@ -907,16 +920,33 @@ export async function runWorkVerification(deps) {
         const h = await deps.repoHealth();
         if (!h.ok) {
             const baseline = deps.healthBaseline ? await deps.healthBaseline() : null;
-            if (classifyHealthDelta(baseline?.outcome ?? null, h) === 'regressed') {
+            const before = baseline?.outcome ?? null;
+            if (classifyHealthDelta(before, h) === 'regressed') {
+                // Named after what REGRESSED, not after whatever failed first: a lint
+                // red on arrival would otherwise stand in for the suite this task broke.
+                const regressed = regressedCommands(before, h);
+                if (regressed.length === 0) {
+                    return {
+                        ok: false,
+                        failClass: 'repo-health',
+                        reason: `repo health: ${h.reason}`,
+                        health: h
+                    };
+                }
+                const failClass = healthFailClass(regressed);
                 return {
                     ok: false,
-                    failClass: 'repo-health',
-                    reason: `repo health: ${h.reason}`,
-                    health: h
+                    failClass,
+                    reason: `${VERIFY_FAIL_PREFIX[failClass]} ${describeHealthFailures(regressed)}`,
+                    health: { ...h, commands: regressed, output: regressed[0].output ?? h.output }
                 };
             }
             pre.repoHealth = inheritedHealthFindings(h);
-            inheritedHealth = `repo health: ${h.reason} — already failing before this task`;
+            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/dist/task/yolo.d.ts

@@ -36,6 +36,10 @@ export type YoloPick = {
  * demotion — an answer proven to name an unverified API identifier. Auto-accepting
  * that would re-promote exactly the invention the demotion exists to stop, so a
  * machine may never take it; a human still can.
+ *
+ * An option that defers a breakage to an owner nobody is, is passed over here
+ * rather than at each caller: the clarify generator, the plan review and an
+ * UNKNOWN's own suggestion reach a machine with no guard in front of them.
  */
 export declare function yoloPickAnswer(enabled: boolean, opts: {
     suggested?: string;
@@ -45,11 +49,11 @@ export declare function yoloPickAnswer(enabled: boolean, opts: {
 /**
  * The same policy expressed over an {@link AutoAnswer}, for the grill site. Of the
  * five `reason` tags an unknown can carry — `api-synthesis`, `deferred-breakage`,
- * `integration`, `threw`, `model-unknown` — the first two are unsafe: one names an
- * API nobody verified, the other hands a red suite to an owner nobody is. The other
+ * `integration`, `threw`, `model-unknown` — `api-synthesis` is unsafe by its tag:
+ * the answer names an API nobody verified. A `deferred-breakage` suggestion is the
+ * deferral itself, which `yoloPickAnswer` passes over for every site. The other
  * three carry an ordinary best-effort recommendation, which is precisely what a
- * human would be shown as the green card. The variants are told apart by that tag,
- * never by pattern-matching the answer text.
+ * human would be shown as the green card.
  */
 export declare function yoloPickAutoAnswer(enabled: boolean, auto: AutoAnswer): YoloPick;
 /**

package/dist/task/yolo.js

@@ -29,6 +29,7 @@
  * the config.
  */
 import { getConfig } from '../config/config.js';
+import { defersBreakage } from './deferred-breakage.js';
 /**
  * Visible provenance marker on the artifacts an auto-pick writes: gate trail lines
  * and the task file's Q&A record (qa-transcript.ts `QA_PROVENANCE`). A later audit
@@ -53,6 +54,10 @@ export function isYoloMode() {
  * demotion — an answer proven to name an unverified API identifier. Auto-accepting
  * that would re-promote exactly the invention the demotion exists to stop, so a
  * machine may never take it; a human still can.
+ *
+ * An option that defers a breakage to an owner nobody is, is passed over here
+ * rather than at each caller: the clarify generator, the plan review and an
+ * UNKNOWN's own suggestion reach a machine with no guard in front of them.
  */
 export function yoloPickAnswer(enabled, opts) {
     if (!enabled)
@@ -60,20 +65,26 @@ export function yoloPickAnswer(enabled, opts) {
     if (opts.unsafe !== undefined && opts.unsafe.length > 0) {
         return { kind: 'skip', note: opts.unsafe };
     }
-    const pick = opts.suggested ?? opts.alt;
-    if (pick === undefined || pick.trim().length === 0) {
+    const offered = [opts.suggested, opts.alt].filter((o) => o !== undefined && o.trim().length > 0);
+    if (offered.length === 0)
         return { kind: 'skip', note: 'no recommended option to take' };
+    const pick = offered.find(o => !defersBreakage(o));
+    if (pick === undefined) {
+        return {
+            kind: 'skip',
+            note: 'the recommended answer leaves a test or build failing for an owner that does not exist — needs a human'
+        };
     }
     return { kind: 'answer', answer: pick };
 }
 /**
  * The same policy expressed over an {@link AutoAnswer}, for the grill site. Of the
  * five `reason` tags an unknown can carry — `api-synthesis`, `deferred-breakage`,
- * `integration`, `threw`, `model-unknown` — the first two are unsafe: one names an
- * API nobody verified, the other hands a red suite to an owner nobody is. The other
+ * `integration`, `threw`, `model-unknown` — `api-synthesis` is unsafe by its tag:
+ * the answer names an API nobody verified. A `deferred-breakage` suggestion is the
+ * deferral itself, which `yoloPickAnswer` passes over for every site. The other
  * three carry an ordinary best-effort recommendation, which is precisely what a
- * human would be shown as the green card. The variants are told apart by that tag,
- * never by pattern-matching the answer text.
+ * human would be shown as the green card.
  */
 export function yoloPickAutoAnswer(enabled, auto) {
     if (!enabled)
@@ -85,9 +96,6 @@ export function yoloPickAutoAnswer(enabled, auto) {
         ...(auto.alt !== undefined && { alt: auto.alt }),
         ...(auto.reason === 'api-synthesis' && {
             unsafe: 'the suggested answer names an unverified API identifier — needs a human'
-        }),
-        ...(auto.reason === 'deferred-breakage' && {
-            unsafe: 'the suggested answer leaves a test or build failing for an owner that does not exist — needs a human'
         })
     });
 }

package/package.json

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