@mjasnikovs/pi-task 0.42.2 → 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

@@ -15,11 +15,12 @@ import { RUN_END_POLICY, runSucceeded } from './run-end.js';
 import { parseAutoAnswer, autoAnswerHasTag, deriveTitle } from './parsers.js';
 import { renderInlineMarkdown, stripInlineMarkdown } from './inline-markdown.js';
 import { AUTO_CLARIFY_PROMPT, AUTO_DECOMPOSE_PROMPT, DECOMPOSE_COVERAGE_PROMPT } from './auto-prompts.js';
+import { defersBreakage } from './deferred-breakage.js';
 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
@@ -37,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';
@@ -220,6 +221,10 @@ async function triageClarifyQuestion(deps, cwd, featureForModel, existingFilesBl
             text = await deps.runChild('clarify-triage', 'read', prependHint(GRILL_AUTO_FORMAT_HINT, basePrompt));
         }
         const parsed = parseAutoAnswer(text);
+        if (parsed.kind === 'answered' && defersBreakage(parsed.text)) {
+            logPlanDebug(cwd, `clarify-triage answer defers a breakage to a nonexistent owner — surfacing: ${parsed.text.replace(/\s+/g, ' ').slice(0, 100)}`);
+            return null;
+        }
         if (parsed.kind === 'answered') {
             logPlanDebug(cwd, `clarify-triage auto-resolved (spec-settled): ${question.replace(/\s+/g, ' ').slice(0, 100)}`
                 + ` → ${parsed.text.replace(/\s+/g, ' ').slice(0, 100)}`);
@@ -387,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))
@@ -604,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,
@@ -1361,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

@@ -0,0 +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

@@ -0,0 +1,110 @@
+/**
+ * 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.
+ */
+/** 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'
+    }
+];
+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) {
+    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;
+}
+/** The one re-ask a deferring answer gets before it is surfaced instead of promoted. */
+export function deferredBreakageReaskHint(answer) {
+    return ('[SYSTEM NOTE: Your previous answer deferred a breakage to someone who does not '
+        + `exist — "${answer.replace(/\s+/g, ' ').slice(0, 160)}". No later step owns a `
+        + 'failing test, lint, or build; each one inherits it and is told not to touch it. '
+        + 'Re-run the GREEN-SUITE CHECK: answer with the option that keeps the suite green, '
+        + 'naming the test file this task must also update. Output ONLY the tagged lines.]');
+}

package/dist/task/final-gate.js

@@ -46,7 +46,7 @@
  */
 import { existsSync, readFileSync } from 'node:fs';
 import * as path from 'node:path';
-import { runRepoHealthCheck, discoverHealthCommands } from './repo-health-check.js';
+import { runRepoHealthCheck, discoverHealthCommands, discoverTestCommands } from './repo-health-check.js';
 import { deriveOpenDebts, rerunDebtVerifyCommand } from './accept-debt.js';
 import { readDeclaredScripts, missingDeclaredScripts, runnableDeclaredScripts } from './launch-contract.js';
 import { readLaunchManifest, inertLaunchContractNote, packageScripts, makeHasTarget } from './launch-manifest.js';
@@ -83,58 +83,21 @@ import { VERIFY_FAIL_PREFIX } from './verify-work.js';
  * tool-by-tool is not the fix either.
  */
 export function discoverIntegrationCommands(cwd) {
-    if (existsSync(path.join(cwd, 'package.json'))) {
-        const s = packageScripts(cwd);
-        const cmds = [];
-        // Every test-shaped script, not just the one literally named `test`: a
-        // project's only browser-executing suite is often `test:ct` or similar, and
-        // looking for `test` alone never runs it. Plain `test` leads, then every
-        // `test:`/`test_`/`test-` prefixed name in declaration order (Array#sort is
-        // stable), then `build`. Measured on a manifest declaring test:ct, build,
-        // test_unit, test-e2e, test, testing and pretest, the result is exactly
-        // test, test:ct, test_unit, test-e2e, build — `testing` and `pretest` do
-        // not match. Env-gap SKIP still applies per command: a suite whose browser
-        // or runtime is absent skips rather than fails (see runGateCommand).
-        const testNames = Object.keys(s).filter(n => n === 'test' || /^test[:_-]/.test(n));
-        testNames.sort((a, b) => a === 'test' ? -1
-            : b === 'test' ? 1
-                : 0);
-        for (const name of testNames)
-            cmds.push(['bun', ['run', name]]);
-        if (s.build)
-            cmds.push(['bun', ['run', 'build']]);
-        return { ecosystem: 'package.json', cmds };
-    }
-    if (existsSync(path.join(cwd, 'Makefile'))) {
-        const cmds = [];
-        for (const target of ['test', 'build']) {
-            if (makeHasTarget(cwd, target))
-                cmds.push(['make', [target]]);
+    const tests = discoverTestCommands(cwd);
+    const build = (() => {
+        if (existsSync(path.join(cwd, 'package.json'))) {
+            return packageScripts(cwd).build ? ['bun', ['run', 'build']] : null;
         }
-        return { ecosystem: 'Makefile', cmds };
-    }
-    if (existsSync(path.join(cwd, 'Cargo.toml'))) {
-        return {
-            ecosystem: 'Cargo.toml',
-            cmds: [
-                ['cargo', ['test', '--quiet']],
-                ['cargo', ['build', '--quiet']]
-            ]
-        };
-    }
-    if (existsSync(path.join(cwd, 'go.mod'))) {
-        return {
-            ecosystem: 'go.mod',
-            cmds: [
-                ['go', ['test', './...']],
-                ['go', ['build', './...']]
-            ]
-        };
-    }
-    if (existsSync(path.join(cwd, 'pyproject.toml'))) {
-        return { ecosystem: 'pyproject.toml', cmds: [['pytest', ['-q']]] };
-    }
-    return { ecosystem: null, cmds: [] };
+        if (existsSync(path.join(cwd, 'Makefile'))) {
+            return makeHasTarget(cwd, 'build') ? ['make', ['build']] : null;
+        }
+        if (existsSync(path.join(cwd, 'Cargo.toml')))
+            return ['cargo', ['build', '--quiet']];
+        if (existsSync(path.join(cwd, 'go.mod')))
+            return ['go', ['build', './...']];
+        return null;
+    })();
+    return { ecosystem: tests.ecosystem, cmds: build ? [...tests.cmds, build] : tests.cmds };
 }
 /**
  * Per-ecosystem lockfile↔manifest consistency checks. A check applies only when

package/dist/task/gate-deps.js

@@ -537,6 +537,9 @@ export async function healthBaselineFor(cwd, taskId, signal) {
             return stored;
         const fresh = await lazyHealthBaseline({
             git: makeGit(cwd, signal),
+            // 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) {
@@ -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,11 +764,8 @@ export function buildGateDeps(params) {
             startedAt,
             lastLine: running ? `repo health · ${running}` : 'repo health'
         }));
-        return runRepoHealthCheck(cwd2, {
-            signal,
-            onCommand: c => {
-                running = c;
-            }
+        return gateHealth(cwd2, c => {
+            running = c;
         }).finally(stop);
     };
     // Adapter onto the shared gate-child runner (gate-child.ts). What survives
@@ -934,20 +958,19 @@ export function buildGateDeps(params) {
                 onStage: label => {
                     stageLine = label;
                 },
-                // Deterministic whole-repo static-analysis gate — runs the project's
-                // own lint/typecheck and fails on a real non-zero exit, independent of
-                // the model-authored VERIFY block, which may not lint at all. ASYNC,
+                // Deterministic whole-repo gate — runs the project's own
+                // lint/typecheck AND its test suite, independent of the
+                // model-authored VERIFY block, which may not lint at all. The suite
+                // is judged only against the baseline below (a task that turned a
+                // green suite red is this task's FAIL, whatever its spec says). ASYNC,
                 // so the lint does not starve pi-tui's nextTick-scheduled renders.
                 //
                 // ONE call, both arms. A baseline arm that dropped the signal or the
                 // 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,
-                    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)`