@mjasnikovs/pi-task 0.42.5 → 0.42.7

package/dist/task/deferred-breakage.js

@@ -31,7 +31,12 @@ const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather t
  * be rephrased away.
  */
 const MODAL = /\b(?:would|could|might)\b/i;
-const HYPOTHETICAL = /\b(?:if|unless|either|whether|option|alternative|otherwise)\b/i;
+/** A condition governs its own half of a semicolon and reaches no further. */
+const CONDITION = /\b(?:if|unless)\b/i;
+/** Options are posed once and weighed in any later clause of the sentence. */
+const OPTION = /\b(?:either|whether|option|alternative|otherwise)\b/i;
+/** Whatever the sentence weighs, "I would …" is the answer's own decision. */
+const FIRST_PERSON = /\b(?:i|we)\s+(?:would|could|might)\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;
@@ -54,7 +59,14 @@ const PHRASES = [
     // 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' },
+    // Ownership handed to a ROLE is handed to nobody: no release manager exists in
+    // a /task-auto run. A named team is someone, so the lookahead hands those to
+    // the `check` rule below rather than listing every job title here.
+    {
+        re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b(?!.*\b(?:teams?|groups?|squads?|guilds?|crews?)\b)/i,
+        needs: 'alone'
+    },
+    { re: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'check' },
     { re: /\bwhoever\b/i, needs: 'check' },
     { re: /\bowned\s+(?:by|follow[- ]?up)\b/i, needs: 'check' },
     { re: /\bleft\s+for\b/i, needs: 'check' },
@@ -94,21 +106,28 @@ function clauses(sentence) {
 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;
-                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;
+        const posesOptions = OPTION.test(sentence);
+        // A semicolon joins two independent clauses, so "the test fails only if X;
+        // it could be flagged as known" states a condition and then decides. The
+        // options the sentence posed reach across it; the condition does not.
+        for (const half of sentence.split(';')) {
+            const weighsOptions = posesOptions || CONDITION.test(half);
+            for (const clause of clauses(half)) {
+                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) && weighsOptions && !FIRST_PERSON.test(before))
+                        continue;
+                    if (needs === 'check' && !aboutACheck(clause))
+                        continue;
+                    if (needs === 'breakage' && !sentenceBreaks)
+                        continue;
+                    return true;
+                }
             }
         }
     }

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

@@ -39,13 +39,16 @@ export type HealthDelta = 'clean' | 'regressed' | 'pre-existing';
  */
 export declare function classifyHealthDelta(baseline: HealthSignal | null, after: HealthSignal): HealthDelta;
 /**
- * Test commands the baseline saw PASS that now find no tests to run.
+ * Test commands the baseline RAN 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.
+ *
+ * Ran, not passed. A baseline that ran the suite RED ran it, and deleting a red
+ * suite is the same move with a larger payoff: the whole check turns 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

package/dist/task/health-baseline.js

@@ -58,19 +58,22 @@ export function classifyHealthDelta(baseline, after) {
 }
 const failureKey = (c) => JSON.stringify([c.cmd, c.exitCode]);
 /**
- * Test commands the baseline saw PASS that now find no tests to run.
+ * Test commands the baseline RAN 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.
+ *
+ * Ran, not passed. A baseline that ran the suite RED ran it, and deleting a red
+ * suite is the same move with a larger payoff: the whole check turns 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));
+    const ran = new Set((baseline.commands ?? []).filter(c => c.outcome !== 'skip').map(c => c.cmd));
+    return (after.commands ?? []).filter(c => c.outcome === 'skip' && c.gap === 'empty-suite' && ran.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. */

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

@@ -22,7 +22,7 @@
  * 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';
+import { type HealthCommandResult } from './repo-health-check.js';
 /** The failing check, and what its output named. */
 export interface HealthRed {
     command: string;
@@ -36,9 +36,13 @@ export interface HealthRedOwners {
     owners: string[];
 }
 /**
- * What a red health result is about: its first failing command that `mayRepair`
+ * What a red health result is about: its first red 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.
+ *
+ * A vanished suite is red here though it failed nothing and left `ok` true. It
+ * is the regression the differential exists to catch, and without a subject
+ * ACCEPT queued no repair for it and the checkpoint spliced none.
  */
 export declare function healthRedSubject(health: HealthSignal & {
     output?: string;

package/dist/task/health-repair.js

@@ -1,3 +1,4 @@
+import { isHealthRed } from './repo-health-check.js';
 import { parseRepairTitleFile } from './root-cause-repair.js';
 import { failClassOfReason } from './verify-work.js';
 /** A path-like token: at least one directory separator, ending in a file name. */
@@ -23,12 +24,16 @@ function resolveTracked(token, cwd, tracked) {
     return bySuffix.length === 1 ? bySuffix[0] : null;
 }
 /**
- * What a red health result is about: its first failing command that `mayRepair`
+ * What a red health result is about: its first red 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.
+ *
+ * A vanished suite is red here though it failed nothing and left `ok` true. It
+ * is the regression the differential exists to catch, and without a subject
+ * ACCEPT queued no repair for it and the checkpoint spliced none.
  */
 export function healthRedSubject(health, cwd, tracked, mayRepair = () => true) {
-    const failing = (health.commands ?? []).find(c => c.outcome === 'fail' && mayRepair(c));
+    const failing = (health.commands ?? []).find(c => isHealthRed(c) && mayRepair(c));
     if (!failing)
         return null;
     const files = [];

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

@@ -115,5 +115,7 @@ export declare function runRepoHealthCheck(cwd: string, opts?: {
      *  that will judge the result DIFFERENTIALLY may set this — see the header. */
     withTests?: boolean;
 }): Promise<HealthOutcome>;
+/** A command the repo owes an answer for: it failed, or its suite went missing. */
+export declare function isHealthRed(c: HealthCommandResult): boolean;
 /** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
 export declare function describeHealthFailures(commands: readonly HealthCommandResult[]): string;

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

@@ -280,10 +280,14 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
         output: ''
     };
 }
+/** A command the repo owes an answer for: it failed, or its suite went missing. */
+export function isHealthRed(c) {
+    return c.outcome === 'fail' || c.gap === 'empty-suite';
+}
 /** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
 export function describeHealthFailures(commands) {
     return commands
-        .filter(c => c.outcome === 'fail' || c.gap === 'empty-suite')
+        .filter(isHealthRed)
         .map(c => c.outcome === 'fail' ?
         `\`${c.cmd}\` exited ${c.exitCode}`
         : `\`${c.cmd}\` found no tests to run`)

package/dist/task/task-gates.js

@@ -1,11 +1,12 @@
 import { verifyFailClass } from './verify-work.js';
 import { resolutionOptions, classifyResolutionAnswer } from './verify-resolution.js';
 import { resolveDisposition } from './gate-resolution.js';
-import { classifyHealthDelta } from './health-baseline.js';
+import { classifyHealthDelta, regressedCommands } from './health-baseline.js';
 import { SessionUI, notifyBoth, notifyRun } from '../remote/bridge.js';
 import { isYoloMode, YOLO_STAMP } from './yolo.js';
 import { extractFailingCommand, findRepairCandidate, summariseDefect } from './root-cause-repair.js';
 import { attributeEnforceFailure } from './enforce-attribution.js';
+import { describeHealthFailures } from './repo-health-check.js';
 import { healthRedSubject, parseHealthRepairTitle } from './health-repair.js';
 // The debt ledger is reached through the injected `recordDebt` dep (so it stays
 // absent-in-tests); only the origin TYPE and the cross-task-deletion reason SHAPE
@@ -417,15 +418,19 @@ export async function runEnforcePass(active, deps, p, rec, routeRootCause, args)
             const delta = classifyHealthDelta(healthBefore ?? null, after);
             if (delta === 'regressed') {
                 enforceEditsBlocked = true;
+                // What REGRESSED, not the check's own verdict: a vanished suite fails
+                // nothing, so `after.reason` reads "tests passed" under this discard.
+                const regressed = regressedCommands(healthBefore ?? null, after);
+                const why = regressed.length > 0 ? describeHealthFailures(regressed) : after.reason;
                 const outputTail = after.output ? ` — output:\n${clampOutput(after.output)}` : '';
                 if (deps.discardEdits) {
                     await deps.discardEdits(p.cwd);
-                    await rec(`enforce: edits discarded pre-commit — REGRESSED repo health (${after.reason})${outputTail}`);
+                    await rec(`enforce: edits discarded pre-commit — REGRESSED repo health (${why})${outputTail}`);
                 }
                 else {
-                    await rec(`enforce: edits REGRESSED repo health pre-commit (${after.reason}) — no discard available, left uncommitted${outputTail}`);
+                    await rec(`enforce: edits REGRESSED repo health pre-commit (${why}) — no discard available, left uncommitted${outputTail}`);
                 }
-                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${after.reason.slice(0, 120)}) — discarded before commit.`, 'warning');
+                notifyRun(active, `${p.tag}: guideline edits on "${p.title}" regressed repo health (${why.slice(0, 120)}) — discarded before commit.`, 'warning');
             }
             else if (delta === 'pre-existing') {
                 // Failing both before and after → not enforce's fault. Keep the edits;

package/dist/task/verify-work.d.ts

@@ -65,9 +65,12 @@ export interface VerifyFail {
     crossTaskDeletions?: CrossTaskDeletion[];
     inheritedHealth?: string;
     /** The health result behind a `repo-health` FAIL: which command, and what its
-     *  output named. What an ACCEPT of this FAIL hands to the repair channel. */
+     *  output named. What an ACCEPT of this FAIL hands to the repair channel.
+     *  `reason` describes what REGRESSED, which is not what the check itself said:
+     *  a vanished suite fails nothing, so the check's verdict reads "tests passed". */
     health?: HealthSignal & {
         output?: string;
+        reason?: string;
     };
     /** What the deterministic probes found for THIS verdict, carried out so an
      *  AUTOFIX re-run is told what the gate already knows (see fix-context.ts)

package/dist/task/verify-work.js

@@ -939,13 +939,17 @@ export async function runWorkVerification(deps) {
                     };
                 }
                 const failClass = healthFailClass(regressed);
+                // Re-minted, never `h.reason`: a vanished suite fails nothing, so the
+                // check's own reason reads "tests passed" under a REGRESSED verdict.
+                const why = describeHealthFailures(regressed);
                 return {
                     ok: false,
                     failClass,
-                    reason: `${VERIFY_FAIL_PREFIX[failClass]} ${describeHealthFailures(regressed)}`,
+                    reason: `${VERIFY_FAIL_PREFIX[failClass]} ${why}`,
                     health: {
                         ...h,
                         ok: false,
+                        reason: why,
                         commands: regressed,
                         output: regressed[0].output ?? h.output
                     }

package/package.json

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