@mjasnikovs/pi-task 0.42.4 → 0.42.5

package/dist/task/accept-debt.js

@@ -36,6 +36,7 @@ import * as path from 'node:path';
 import * as fsp from 'node:fs/promises';
 import { runVerifyCommandLine, spawnCommand } from './command-run.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';
@@ -341,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 {
@@ -355,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) {
@@ -395,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);
@@ -423,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`);
@@ -438,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/deferred-breakage.d.ts

@@ -11,12 +11,11 @@
  * The phrases are the ones a model reaches for when it wants to defer, not the
  * word "test" — "add a test later" is a plan, not a deferral.
  *
- * SCOPE IS GRAMMATICAL, never a character count. A negation or a conditional
- * cancels a phrase only inside the phrase's own clause: "rather than flag it as a
- * known issue" rejects the phrase, and "without touching the test file, accepting
- * that it fails" does not. "Known issue", "follow-up" and "a later step" also name
- * legitimate plans — an upstream bug, a scope cut — so they count only in a clause
- * about a check.
+ * 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. */

package/dist/task/deferred-breakage.js

@@ -11,23 +11,31 @@
  * The phrases are the ones a model reaches for when it wants to defer, not the
  * word "test" — "add a test later" is a plan, not a deferral.
  *
- * SCOPE IS GRAMMATICAL, never a character count. A negation or a conditional
- * cancels a phrase only inside the phrase's own clause: "rather than flag it as a
- * known issue" rejects the phrase, and "without touching the test file, accepting
- * that it fails" does not. "Known issue", "follow-up" and "a later step" also name
- * legitimate plans — an upstream bug, a scope cut — so they count only in a clause
- * about a check.
+ * 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, or it is what an option
- *  WOULD do — "IF NOT EXISTS would still leave the test failing" weighs an option. */
-const NOT_A_DECISION = /\b(?:not|never|no|don't|do not|doesn't|does not|rather than|instead of|isn't|is not|without|avoid|avoiding|would|could|might)\b/i;
-/** Where one clause ends and the next begins. */
-const CLAUSE_BOUNDARY = /[,:()]|\s[—–-]\s|\b(?:and|but|so|then|while|whereas|although|though|because|since|however)\b/gi;
-const SENTENCE_BOUNDARY = /[.!?](?=\s|$)|;|\n/;
+/** 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 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' },
     {
@@ -43,9 +51,12 @@ const PHRASES = [
         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: /\bownership\s+(?:belongs|lies|rests)\s+(?:to|with)\b/i, needs: 'check' },
     { re: /\bleft\s+for\b/i, needs: 'check' },
     { re: /\bknown[- ]issues?\b/i, needs: 'check' },
     { re: /\bfollow[- ]?ups?\b/i, needs: 'check' },
@@ -88,7 +99,10 @@ export function defersBreakage(answer) {
                 const hit = re.exec(clause);
                 if (!hit)
                     continue;
-                if (NOT_A_DECISION.test(clause.slice(0, hit.index)))
+                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;

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.
  *
@@ -730,7 +745,8 @@ export function buildGateDeps(params) {
     // 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.
+    // 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 {
@@ -739,7 +755,7 @@ export function buildGateDeps(params) {
         finally {
             const after = before ? await untrackedFiles(cwd2) : null;
             for (const rel of after ?? []) {
-                if (!before?.has(rel)) {
+                if (!before?.has(rel) && !isSuiteRecord(rel)) {
                     await fsp
                         .rm(path.join(cwd2, rel), { recursive: true, force: true })
                         .catch(() => { });

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

@@ -38,6 +38,16 @@ export type HealthDelta = 'clean' | 'regressed' | 'pre-existing';
  * default the enforce site used to carry.
  */
 export declare function classifyHealthDelta(baseline: HealthSignal | null, after: HealthSignal): HealthDelta;
+/**
+ * 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[];

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)
@@ -55,11 +57,29 @@ export function classifyHealthDelta(baseline, after) {
     return regressedCommands(baseline, after).length > 0 ? 'regressed' : 'pre-existing';
 }
 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)));
+    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

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

@@ -1,4 +1,4 @@
-import { type CommandRunner } from './command-run.js';
+import { type CommandGapId, type CommandRunner } from './command-run.js';
 /**
  * What ONE discovered command did. `outcome` is `classifyCommandRun`'s verdict, so
  * a tool that could not run at all is `skip` rather than a zero-exit pass.
@@ -18,6 +18,9 @@ export interface HealthCommandResult {
     /** Absent on a record written before the suite joined the check, which ran
      *  statics only. A test red is judged, owed and repaired differently. */
     kind?: 'static' | 'test';
+    /** Why nothing was observed, on a `skip`. The differential reads it: a runner
+     *  that found no tests is a gap alone and a regression against a suite. */
+    gap?: CommandGapId;
     /** This command's own captured output, on a `fail` only. */
     output?: string;
 }

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

@@ -125,9 +125,16 @@ export function discoverHealthCommands(cwd) {
     }
     return { ecosystem: null, cmds: [] };
 }
-/** `test:watch`, `jest --watchAll`, `vitest watch`, `bun test --watch`. */
+/**
+ * `test:watch`, `jest --watchAll`, `vitest watch`, `bun test --watch`.
+ *
+ * The flag is read by its VALUE, not its presence: `--watchAll=false` is how a CI
+ * script turns watch off, and excluding it drops the only `test` script such a
+ * repo has.
+ */
 function isWatchScript(name, body) {
-    return (/watch/i.test(name) || /(?:^|\s)--watch(?:All)?(?=[\s=]|$)|(?:^|\s)watch(?=\s|$)/.test(body));
+    return (/watch/i.test(name)
+        || /(?:^|\s)--watch(?:All)?(?:=(?:true|1))?(?=\s|$)|(?:^|\s)watch(?=\s|$)/.test(body));
 }
 /**
  * The project's OWN test commands, in the order the run-end gate runs them. One
@@ -242,7 +249,8 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
                 cmd,
                 outcome: passed ? 'pass' : 'skip',
                 exitCode: passed ? 0 : null,
-                kind
+                kind,
+                ...(verdict.outcome === 'gap' ? { gap: verdict.gap } : {})
             });
             continue;
         }
@@ -275,7 +283,9 @@ export async function runRepoHealthCheck(cwd, opts = {}) {
 /** "`bun run lint` exited 1; `bun run test` exited 1" — every failing command. */
 export function describeHealthFailures(commands) {
     return commands
-        .filter(c => c.outcome === 'fail')
-        .map(c => `\`${c.cmd}\` exited ${c.exitCode}`)
+        .filter(c => c.outcome === 'fail' || c.gap === 'empty-suite')
+        .map(c => c.outcome === 'fail' ?
+        `\`${c.cmd}\` exited ${c.exitCode}`
+        : `\`${c.cmd}\` found no tests to run`)
         .join('; ');
 }

package/dist/task/verify-work.js

@@ -918,7 +918,12 @@ export async function runWorkVerification(deps) {
     if (deps.repoHealth) {
         stage('repo health');
         const h = await deps.repoHealth();
-        if (!h.ok) {
+        // `ok` is not the whole verdict: a suite this tree no longer finds observes
+        // nothing, so nothing fails, and only the differential sees it went away.
+        // Establishing a baseline can cost a worktree health run, so it is asked for
+        // only in the two shapes it can speak to.
+        const suiteGone = (h.commands ?? []).some(c => c.gap === 'empty-suite');
+        if (!h.ok || suiteGone) {
             const baseline = deps.healthBaseline ? await deps.healthBaseline() : null;
             const before = baseline?.outcome ?? null;
             if (classifyHealthDelta(before, h) === 'regressed') {
@@ -938,15 +943,22 @@ export async function runWorkVerification(deps) {
                     ok: false,
                     failClass,
                     reason: `${VERIFY_FAIL_PREFIX[failClass]} ${describeHealthFailures(regressed)}`,
-                    health: { ...h, commands: regressed, output: regressed[0].output ?? h.output }
+                    health: {
+                        ...h,
+                        ok: false,
+                        commands: regressed,
+                        output: regressed[0].output ?? h.output
+                    }
                 };
             }
-            pre.repoHealth = inheritedHealthFindings(h);
-            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`;
+            if (!h.ok) {
+                pre.repoHealth = inheritedHealthFindings(h);
+                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/package.json

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