@mjasnikovs/pi-task 0.42.2 → 0.42.3

package/dist/task/auto-orchestrator.js

@@ -15,6 +15,7 @@ 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';
@@ -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)}`);

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

@@ -0,0 +1,3 @@
+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,48 @@
+/**
+ * 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.
+ */
+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
+];
+/** "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;
+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))
+                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,7 +537,7 @@ export async function healthBaselineFor(cwd, taskId, signal) {
             return stored;
         const fresh = await lazyHealthBaseline({
             git: makeGit(cwd, signal),
-            runHealthIn: dir => runRepoHealthCheck(dir, { signal })
+            runHealthIn: dir => runRepoHealthCheck(dir, { signal, withTests: true })
         });
         if (fresh) {
             await setTaskSection(cwd, taskId, HEALTH_BASELINE_SECTION, formatHealthBaseline(fresh)).catch(() => { });
@@ -739,6 +739,7 @@ export function buildGateDeps(params) {
         }));
         return runRepoHealthCheck(cwd2, {
             signal,
+            withTests: true,
             onCommand: c => {
                 running = c;
             }
@@ -934,9 +935,11 @@ 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
@@ -945,6 +948,7 @@ export function buildGateDeps(params) {
                 // the LOADER, above.
                 repoHealth: () => runRepoHealthCheck(cwd2, {
                     signal,
+                    withTests: true,
                     onCommand: c => {
                         stageLine = `repo health · ${c}`;
                     }

package/dist/task/parsers.d.ts

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

package/dist/task/phases.js

@@ -18,6 +18,7 @@ import { getConfig } from '../config/config.js';
 import { buildExternalContext, gatherExternalContext } from './external-context.js';
 import { currentRunContext } from './run-context.js';
 import { readableMentions } from './mentions.js';
+import { defersBreakage, deferredBreakageReaskHint } from './deferred-breakage.js';
 import { REFINE_PROMPT, RESEARCH_FILES_PROMPT, RESEARCH_APIS_PROMPT, RESEARCH_CONTEXT_PROMPT, RESEARCH_TOOLING_PROMPT, GRILL_GEN_PROMPT, GRILL_AUTO_ANSWER_PROMPT, GRILL_AUTO_FORMAT_HINT, COMPOSE_PROMPT, CRITIQUE_PROMPT, CRITIQUE_TRIAGE_PROMPT, VERIFY_TOOLING_PROMPT, MAX_GRILL_QUESTIONS } from './prompts.js';
 import { appendGateRecord, readSection, readTaskFile, removeTaskSection, setTaskSection, updateTaskFrontMatter } from './task-io.js';
 import { extractSection } from './task-parsers.js';
@@ -770,6 +771,37 @@ export async function phaseAutoAnswer(deps, refined, research, question) {
                 }
             }
         }
+        // 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/prompts.d.ts

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

package/dist/task/prompts.js

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

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

@@ -56,6 +56,21 @@ export declare function discoverHealthCommands(cwd: string): {
     ecosystem: string | null;
     cmds: HealthCommand[];
 };
+/**
+ * The project's OWN test commands, in the order the run-end gate runs them. One
+ * statement for both gates: final-gate.ts appends `build` to this list for the
+ * integration half, and `runRepoHealthCheck` runs it under `withTests` for the
+ * per-task differential, so the two cannot drift apart.
+ *
+ * Every test-shaped script, not just the one literally named `test`: a project's
+ * only browser-executing suite is often `test:ct`, and looking for `test` alone
+ * never runs it. Plain `test` leads, then every `test:`/`test_`/`test-` name in
+ * declaration order (Array#sort is stable).
+ */
+export declare function discoverTestCommands(cwd: string): {
+    ecosystem: string | null;
+    cmds: HealthCommand[];
+};
 /** Progress hook: called with each command's label as it STARTS, so a caller can
  *  keep a live status line naming what is currently running. */
 export type HealthProgress = (command: string) => void;
@@ -86,4 +101,7 @@ export declare function runRepoHealthCheck(cwd: string, opts?: {
     onCommand?: HealthProgress;
     /** The spawner. Injected so a verdict is testable without a real shell. */
     run?: CommandRunner;
+    /** Also run the project's test commands, after the statics. Only a caller
+     *  that will judge the result DIFFERENTIALLY may set this — see the header. */
+    withTests?: boolean;
 }): Promise<HealthOutcome>;

package/dist/task/repo-health-check.js

@@ -14,11 +14,18 @@
  * verify gate's `repo-health` FAIL (verify-work.ts), which reaches the
  * AUTOFIX / ACCEPT picker in verify-resolution.ts.
  *
- * Scope is deliberately STATIC ANALYSIS ONLY (lint / typecheck / clippy / vet), never
- * `test`, `build`, `run`, or anything that boots a server or needs a database. Those
- * depend on external services the verify prompt already carves out as an environment
- * gap, so running them here would blame code for a missing database. Static analysis
- * is hermetic: it needs no network, no service and no fixtures.
+ * Scope is STATIC ANALYSIS (lint / typecheck / clippy / vet) by default, never
+ * `build`, `run`, or anything that boots a server. Static analysis is hermetic: it
+ * needs no network, no service and no fixtures, so its absolute exit code decides.
+ *
+ * The TEST suite joins only under `withTests`, and only for the DIFFERENTIAL
+ * (health-baseline.ts). MEASURED (mx5-n TASK_0004, 2026-09-17): a task turned a
+ * green suite red, its spec called that a "known issue for the test owner", the
+ * model gate passed it, and four tasks later the run stalled on an unsatisfiable
+ * spec. A suite that needs a database fails the same way before and after the
+ * task, which the differential reads as pre-existing — so running it here does
+ * not blame code for a missing database, and DOES blame the task that broke a
+ * suite the baseline saw green.
  *
  * Absence is a PASS, two ways: (1) no recognised manifest at all (a pure-docs or
  * config-only repo has nothing that can regress); (2) a manifest with no static-check
@@ -118,6 +125,43 @@ export function discoverHealthCommands(cwd) {
     }
     return { ecosystem: null, cmds: [] };
 }
+/**
+ * The project's OWN test commands, in the order the run-end gate runs them. One
+ * statement for both gates: final-gate.ts appends `build` to this list for the
+ * integration half, and `runRepoHealthCheck` runs it under `withTests` for the
+ * per-task differential, so the two cannot drift apart.
+ *
+ * Every test-shaped script, not just the one literally named `test`: a project's
+ * only browser-executing suite is often `test:ct`, and looking for `test` alone
+ * never runs it. Plain `test` leads, then every `test:`/`test_`/`test-` name in
+ * declaration order (Array#sort is stable).
+ */
+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));
+        names.sort((a, b) => a === 'test' ? -1
+            : b === 'test' ? 1
+                : 0);
+        return { ecosystem: 'package.json', cmds: names.map(n => ['bun', ['run', n]]) };
+    }
+    if (existsSync(path.join(cwd, 'Makefile'))) {
+        return {
+            ecosystem: 'Makefile',
+            cmds: makeHasTarget(cwd, 'test') ? [['make', ['test']]] : []
+        };
+    }
+    if (existsSync(path.join(cwd, 'Cargo.toml'))) {
+        return { ecosystem: 'Cargo.toml', cmds: [['cargo', ['test', '--quiet']]] };
+    }
+    if (existsSync(path.join(cwd, 'go.mod'))) {
+        return { ecosystem: 'go.mod', cmds: [['go', ['test', './...']]] };
+    }
+    if (existsSync(path.join(cwd, 'pyproject.toml'))) {
+        return { ecosystem: 'pyproject.toml', cmds: [['pytest', ['-q']]] };
+    }
+    return { ecosystem: null, cmds: [] };
+}
 /** The nothing-to-run outcome, shared by both runners. */
 function noCommandOutcome(ecosystem) {
     return {
@@ -150,12 +194,18 @@ function noCommandOutcome(ecosystem) {
  * widget has just been cleared.
  */
 export async function runRepoHealthCheck(cwd, opts = {}) {
-    const { ecosystem, cmds } = discoverHealthCommands(cwd);
+    const statics = discoverHealthCommands(cwd);
+    const tests = opts.withTests ? discoverTestCommands(cwd) : { ecosystem: null, cmds: [] };
+    const ecosystem = statics.ecosystem ?? tests.ecosystem;
+    const cmds = [
+        ...statics.cmds.map(([bin, args]) => ({ bin, args, test: false })),
+        ...tests.cmds.map(([bin, args]) => ({ bin, args, test: true }))
+    ];
     if (!ecosystem || cmds.length === 0)
         return noCommandOutcome(ecosystem);
     const run = opts.run ?? spawnCommand;
     const commands = [];
-    for (const [bin, args] of cmds) {
+    for (const { bin, args, test } of cmds) {
         const cmd = `${bin} ${args.join(' ')}`;
         opts.onCommand?.(cmd);
         // Runner resolution: a PATH-stripped environment must not
@@ -175,12 +225,11 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
         // ladder's `tail` keeps 400 characters, and that difference is real — a
         // truncated lint report is unactionable. So the run is classified, not
         // consumed: the verdict decides, the raw streams are what we show.
-        // `runtimeGap: false` — this ladder is NARROWER than the gate's. The
-        // browser/runtime row was written for the gate's TEST commands; here the
-        // commands are lint and typecheck, and its pattern matches ordinary
-        // English, so a genuine report quoting "browsers are not installed" would
-        // skip the static check and certify the repo healthy.
-        const verdict = classifyCommandRun(r, [], { runtimeGap: false });
+        // `runtimeGap` 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 });
         if (verdict.outcome !== 'fail') {
             const passed = verdict.outcome === 'pass';
             commands.push({ cmd, outcome: passed ? 'pass' : 'skip', exitCode: passed ? 0 : null });
@@ -197,7 +246,7 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
     }
     return {
         ok: true,
-        reason: `${ecosystem}: static checks passed`,
+        reason: `${ecosystem}: static checks${tests.cmds.length > 0 ? ' and tests' : ''} passed`,
         ecosystem,
         commands,
         output: ''

package/dist/task/yolo.d.ts

@@ -44,11 +44,12 @@ export declare function yoloPickAnswer(enabled: boolean, opts: {
 }): YoloPick;
 /**
  * The same policy expressed over an {@link AutoAnswer}, for the grill site. Of the
- * four `reason` tags an unknown can carry — `api-synthesis`, `integration`,
- * `threw`, `model-unknown` — only ANTI-SYNTHESIS is unsafe. 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.
+ * 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
+ * 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.
  */
 export declare function yoloPickAutoAnswer(enabled: boolean, auto: AutoAnswer): YoloPick;
 /**

package/dist/task/yolo.js

@@ -68,11 +68,12 @@ export function yoloPickAnswer(enabled, opts) {
 }
 /**
  * The same policy expressed over an {@link AutoAnswer}, for the grill site. Of the
- * four `reason` tags an unknown can carry — `api-synthesis`, `integration`,
- * `threw`, `model-unknown` — only ANTI-SYNTHESIS is unsafe. 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.
+ * 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
+ * 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.
  */
 export function yoloPickAutoAnswer(enabled, auto) {
     if (!enabled)
@@ -84,6 +85,9 @@ 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.2",
+    "version": "0.42.3",
     "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",