@mjasnikovs/pi-task 0.42.3 → 0.42.5

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

package/dist/task/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,22 @@
+/**
+ * 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 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,109 @@
  * 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 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. */
+const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather than|instead of|isn't|is not|without|avoid|avoiding)\b/i;
+/**
+ * A modal cancels a phrase only where the sentence poses an option for it to
+ * weigh: "IF NOT EXISTS would still leave the test failing" describes what a
+ * rejected option does. A bare hedge does not — "I would flag it as a known
+ * issue" is the decision, and treating every modal as hypothetical let the guard
+ * be rephrased away.
  */
-const 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
+const MODAL = /\b(?:would|could|might)\b/i;
+const HYPOTHETICAL = /\b(?:if|unless|either|whether|option|alternative|otherwise)\b/i;
+/** Where one clause ends and the next begins. A semicolon joins clauses of ONE
+ *  thought, so the breakage a clause defers may sit in the other half. */
+const CLAUSE_BOUNDARY = /[,:;()]|\s[—–-]\s|\b(?:and|but|so|then|while|whereas|although|though|because|since|however)\b/gi;
+const SENTENCE_BOUNDARY = /[.!?](?=\s|$)|\n/;
+const PHRASES = [
+    { re: /\b(?:test|suite)[- ]owners?\b/i, needs: 'alone' },
+    {
+        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' },
+    // Handing the work to an unnamed someone is the deferral itself, whatever the
+    // clause is about; bare `whoever` below still needs a check to be one.
+    { re: /\bwhoever\s+(?:owns|revisits|maintains|touches)\b/i, needs: 'alone' },
+    { re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'alone' },
+    { re: /\bwhoever\b/i, needs: 'check' },
+    { re: /\bowned\s+(?:by|follow[- ]?up)\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;
+                const before = clause.slice(0, hit.index);
+                if (NOT_A_DECISION.test(before))
+                    continue;
+                if (MODAL.test(before) && HYPOTHETICAL.test(sentence))
+                    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.d.ts

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

package/dist/task/gate-deps.js

@@ -82,6 +82,21 @@ export function truncateToolResult(text, limit = TOOL_RESULT_LOG_LIMIT) {
 }
 /** Keep the gate machinery's own artifacts out of every git pathspec below. */
 const EXCLUDE_TASKS_DIR = ':(exclude).pi-tasks';
+/**
+ * A file the suite wrote as the repo's OWN record, not as a report about the run.
+ * A test added this task and never run locally generates its snapshot on the
+ * gate's run; deleting it commits a snapshot test with no snapshot, and the next
+ * suite — or CI — fails on a file the task was supposed to carry.
+ *
+ * A named set, not a shape test: the alternative is an allowlist of throwaway
+ * artefacts, and anything it misses rides into the commit, which is the problem
+ * the cleanup exists for. A stray snapshot is the smaller error.
+ */
+export function isSuiteRecord(rel) {
+    return (/(?:^|[\\/])__(?:snapshots|image_snapshots)__[\\/]/.test(rel)
+        || /\.snap$/.test(rel)
+        || /\.approved\.[^.\\/]+$/.test(rel));
+}
 /**
  * Pin the diff header prefixes on any command whose output we PARSE for paths.
  *
@@ -537,7 +552,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 +738,32 @@ 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 — except what it wrote as the
+    // repo's own record (see isSuiteRecord).
+    const gateHealth = (cwd2, onCommand) => currentRunContext(cwd2).healthFor(async () => {
+        const before = await untrackedFiles(cwd2);
+        try {
+            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) && !isSuiteRecord(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 +780,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 +985,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,24 @@ 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. */
+/**
+ * Test commands the baseline saw PASS that now find no tests to run.
+ *
+ * A runner that found nothing observed nothing, which is a gap — in isolation. A
+ * task that deleted the test directory, renamed it, or broke the config's glob
+ * leaves the same gap, and the check reports the repo healthy because a gap never
+ * fails. Against a baseline that ran the suite, the suite is gone: this task's
+ * regression, and the largest one it can hide behind a green.
+ */
+export declare function vanishedSuites(baseline: HealthSignal | null, after: HealthSignal): HealthCommandResult[];
+/** The failing commands the baseline did not have failing the same way — what a
+ *  `regressed` verdict is about. Every failing command when there is no baseline. */
+export declare function regressedCommands(baseline: HealthSignal | null, after: HealthSignal): HealthCommandResult[];
+/**
+ * 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 +63,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

@@ -41,6 +41,8 @@ function failures(signal) {
  * default the enforce site used to carry.
  */
 export function classifyHealthDelta(baseline, after) {
+    if (vanishedSuites(baseline, after).length > 0)
+        return 'regressed';
     if (after.ok)
         return 'clean';
     if (!baseline)
@@ -52,13 +54,42 @@ 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]);
+/**
+ * Test commands the baseline saw PASS that now find no tests to run.
+ *
+ * A runner that found nothing observed nothing, which is a gap — in isolation. A
+ * task that deleted the test directory, renamed it, or broke the config's glob
+ * leaves the same gap, and the check reports the repo healthy because a gap never
+ * fails. Against a baseline that ran the suite, the suite is gone: this task's
+ * regression, and the largest one it can hide behind a green.
+ */
+export function vanishedSuites(baseline, after) {
+    if (!baseline)
+        return [];
+    const passed = new Set((baseline.commands ?? []).filter(c => c.outcome === 'pass').map(c => c.cmd));
+    return (after.commands ?? []).filter(c => c.outcome === 'skip' && c.gap === 'empty-suite' && passed.has(c.cmd));
+}
+/** The failing commands the baseline did not have failing the same way — what a
+ *  `regressed` verdict is about. Every failing command when there is no baseline. */
+export function regressedCommands(baseline, after) {
+    const wasFailing = new Set(baseline ? failures(baseline).map(failureKey) : []);
+    return [
+        ...failures(after).filter(c => !wasFailing.has(failureKey(c))),
+        ...vanishedSuites(baseline, after)
+    ];
+}
+/**
+ * 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 +98,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