@mjasnikovs/pi-task 0.42.2 → 0.42.4

package/dist/task/verify-work.js

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

package/dist/task/yolo.d.ts

@@ -36,6 +36,10 @@ export type YoloPick = {
  * demotion — an answer proven to name an unverified API identifier. Auto-accepting
  * that would re-promote exactly the invention the demotion exists to stop, so a
  * machine may never take it; a human still can.
+ *
+ * An option that defers a breakage to an owner nobody is, is passed over here
+ * rather than at each caller: the clarify generator, the plan review and an
+ * UNKNOWN's own suggestion reach a machine with no guard in front of them.
  */
 export declare function yoloPickAnswer(enabled: boolean, opts: {
     suggested?: string;
@@ -44,11 +48,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` — `api-synthesis` is unsafe by its tag:
+ * the answer names an API nobody verified. A `deferred-breakage` suggestion is the
+ * deferral itself, which `yoloPickAnswer` passes over for every site. The other
+ * three carry an ordinary best-effort recommendation, which is precisely what a
+ * human would be shown as the green card.
  */
 export declare function yoloPickAutoAnswer(enabled: boolean, auto: AutoAnswer): YoloPick;
 /**

package/dist/task/yolo.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.42.2",
+    "version": "0.42.4",
     "description": "Deterministic task planning and spec-orchestration for local models — crash-safe /task pipelines with verify/enforce gates, a real-time remote web view, and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",