@mjasnikovs/pi-task 0.40.50 → 0.42.0

package/dist/task/suppression-probe.js

@@ -0,0 +1,78 @@
+/**
+ * The shipped rows. Each `re` is a LINE test, so a pattern that appears inside a
+ * string literal or a comment still counts — the point is the suppression's
+ * presence in the shipped file, and deciding what is "really" a suppression would
+ * need a parser per language to answer worse.
+ */
+export const SUPPRESSION_PATTERNS = [
+    { id: '@ts-expect-error', re: /@ts-expect-error/, ecosystems: ['npm'] },
+    { id: '@ts-ignore', re: /@ts-ignore/, ecosystems: ['npm'] },
+    { id: 'eslint-disable', re: /eslint-disable/, ecosystems: ['npm'] },
+    { id: 'as unknown as', re: /\bas\s+unknown\s+as\b/, ecosystems: ['npm'] },
+    { id: '#[allow(', re: /#\[allow\(/, ecosystems: ['cargo'] },
+    { id: '# noqa', re: /#\s*noqa\b/i },
+    { id: '# type: ignore', re: /#\s*type:\s*ignore\b/ },
+    { id: '//nolint', re: /\/\/\s*nolint\b/, ecosystems: ['go'] },
+    { id: '@SuppressWarnings', re: /@SuppressWarnings\b/ },
+    { id: '#pragma warning disable', re: /#pragma\s+warning\s+disable\b/ }
+];
+/**
+ * Compile the extra patterns a project configures. An unparseable source is
+ * dropped rather than thrown: a hand-edited config may not break the gate, and a
+ * pattern nobody can compile finds nothing either way.
+ */
+export function compileSuppressionPatterns(sources) {
+    const out = [];
+    for (const source of sources) {
+        try {
+            out.push({ id: source, re: new RegExp(source) });
+        }
+        catch {
+            // an invalid regex is a config defect, not a gate failure
+        }
+    }
+    return out;
+}
+/** The rows in force for a project: the shipped ones its ecosystems claim, plus
+ *  every configured one (a user pattern is never ecosystem-gated — they wrote it
+ *  for this repo). */
+export function suppressionPatternsFor(ecosystems, extra = []) {
+    const shipped = SUPPRESSION_PATTERNS.filter(p => !p.ecosystems
+        || ecosystems.length === 0
+        || p.ecosystems.some(e => ecosystems.includes(e)));
+    return [...shipped, ...extra];
+}
+/**
+ * Net-new suppressions per file and pattern, in a stable order (file, then
+ * registry order) so two runs over the same diff produce the same findings.
+ */
+export function findSuppressionWidening(lines, patterns = SUPPRESSION_PATTERNS) {
+    // Keyed by path then pattern rather than by a joined string: any separator
+    // would have to be a character no path can contain, and `\0` — the honest
+    // choice — is a byte prettier rewrites and plain grep cannot see.
+    const byPath = new Map();
+    const hits = [];
+    for (const line of lines) {
+        for (const pattern of patterns) {
+            if (!pattern.re.test(line.text))
+                continue;
+            let byPattern = byPath.get(line.path);
+            if (!byPattern) {
+                byPattern = new Map();
+                byPath.set(line.path, byPattern);
+            }
+            let hit = byPattern.get(pattern.id);
+            if (!hit) {
+                hit = { path: line.path, patternId: pattern.id, net: 0 };
+                byPattern.set(pattern.id, hit);
+                hits.push(hit);
+            }
+            hit.net += line.added ? 1 : -1;
+        }
+    }
+    return hits.filter(h => h.net > 0).sort((a, b) => a.path.localeCompare(b.path));
+}
+/** The verify prompt's finding lines for the suppression-widening row. */
+export function suppressionVerifyFindings(hits) {
+    return hits.map(h => `${h.path} — ${h.net} net-new \`${h.patternId}\` line${h.net === 1 ? '' : 's'} added by this task`);
+}

package/dist/task/task-gates.d.ts

@@ -6,11 +6,11 @@
  * just-finished work:
  *
  *   1. VERIFY — RUN the composed spec's VERIFY block in the real workspace and
- *      judge a PASS/FAIL. On a FAIL a fresh read-only child recommends AUTOFIX or
- *      ACCEPT: an AUTOFIX recommendation re-runs the implementation turn UNATTENDED
- *      (no prompt) and loops back to the gate, bounded by MAX_AUTO_AUTOFIX; the user
- *      is shown the boxed picker only when the recommendation is ACCEPT (blessing the
- *      artifact as-is) or when that unattended-autofix cap is reached.
+ *      judge a PASS/FAIL. A FAIL goes to gate-resolution.ts's decision table,
+ *      which returns one of three actions: re-run the implementation turn
+ *      UNATTENDED and loop back, accept the artifact and write the defect to the
+ *      debt ledger, or show the user the boxed picker. This module owns none of
+ *      that policy — it only carries the actions out.
  *   2. ENFORCE — hold the committed work to the project's AGENTS.md / CLAUDE.md
  *      rules. Runs in `edit` mode (fix in place) only when the verify gate produced
  *      a genuine clean pass to guard the edits against; otherwise `flag` mode
@@ -34,8 +34,11 @@ import type { CommitResult } from './auto-commit.js';
 import { type VerifyOutcome } from './verify-work.js';
 import type { EnforceOutcome } from './enforce-guidelines.js';
 import { type ResolutionOutcome, type ResolutionChoice } from './verify-resolution.js';
+import { type HealthBaseline, type HealthSignal } from './health-baseline.js';
+import type { LintFixResult } from './lint-fix.js';
 import { type RepairCandidate } from './root-cause-repair.js';
 import { type DebtOrigin } from './accept-debt.js';
+import type { FixContext } from './fix-context.js';
 /**
  * The deps the gate sequence drives. A superset of these is built once per command
  * by buildGateDeps; AutoDeps extends this with the planning-only `runChild`. Every
@@ -53,7 +56,9 @@ export interface GateDeps {
         resumeId?: string;
         onStart?: (taskId: string) => void | Promise<void>;
         planContext?: string;
-        fixInstruction?: string;
+        planKey?: string;
+        fixContext?: FixContext;
+        healthBaseline?: (ctx: ExtensionCommandContext) => Promise<HealthBaseline | null>;
     }) => Promise<RunSingleTaskResult>;
     /** Snapshot the working tree into one commit after a task passes. */
     commit: (cwd: string, message: string) => Promise<CommitResult>;
@@ -80,9 +85,10 @@ export interface GateDeps {
      */
     enforce?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, mode: 'edit' | 'flag') => Promise<EnforceOutcome>;
     /**
-     * After a verify FAIL, research whether to recommend AUTOFIX or ACCEPT — only
-     * sets which card the picker tints RECOMMENDED; the user always decides. Absent
-     * → the picker defaults the recommendation to AUTOFIX.
+     * After a verify FAIL, research whether the work is genuinely wrong (AUTOFIX),
+     * good as-is (ACCEPT), or blocked by a contradiction in its own spec. One input
+     * to the decision table, which alone decides what happens next. Absent → the
+     * table sees the conservative AUTOFIX default.
      */
     recommend?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string, failReason: string) => Promise<ResolutionOutcome>;
     /**
@@ -96,13 +102,11 @@ export interface GateDeps {
      * exactly the static findings (revert-guarded — see lint-fix.ts), instead of the
      * full implementation re-run AUTOFIX reaches for. Smallest tool first: a static
      * finding does not need the whole turn re-run to fix it. Runs at most once per
-     * gate sequence; not-applied falls through to the picker. Absent → the loop goes
-     * straight to recommend/picker.
+     * gate sequence; a `frozen-path` result mints the SpecContradiction that ends
+     * the loop, anything else falls through to the decision table unchanged. Absent
+     * → the loop goes straight to the judge and the table.
      */
-    lintFix?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string, failReason: string) => Promise<{
-        ok: boolean;
-        reason?: string;
-    }>;
+    lintFix?: (ctx: ExtensionCommandContext, cwd: string, taskTitle: string, taskId: string, failReason: string) => Promise<LintFixResult>;
     /**
      * Deterministic whole-repo static check (repo-health), used as the PRE-COMMIT
      * gate on an edit-mode enforce pass: an enforce edit that breaks the project's
@@ -118,7 +122,16 @@ export interface GateDeps {
         ok: boolean;
         reason: string;
         output?: string;
-    }>;
+    } & HealthSignal>;
+    /**
+     * Record what the same static checks say about the tree RIGHT NOW, as the
+     * baseline a later verify differential attributes against (health-baseline.ts).
+     * Called where the tree is committed and the task has not started — the
+     * `/task-auto` pre-task checkpoint, and `/task`'s own start. Null when the
+     * capture could not run; absent in tests → no baseline is written and the
+     * verify gate establishes one lazily.
+     */
+    captureHealthBaseline?: (ctx: ExtensionCommandContext, cwd: string, label: string) => Promise<HealthBaseline | null>;
     /** Does the working tree hold changes (excluding .pi-tasks)? Lets the pre-commit
      *  health check run only when the enforce pass actually edited something. */
     dirty?: (cwd: string) => Promise<boolean>;
@@ -140,12 +153,13 @@ export interface GateDeps {
      * see accept-debt.ts), stamped with the DebtOrigin that says how it was reached.
      * The final integration gate re-checks every recorded debt at run end and surfaces
      * the ones still open, so a defect the gate found is never lost by whatever the
-     * loop then did with the WORK — accepted by a human ('accepted'), auto-picked
-     * unattended by yolo mode ('yolo-accepted'), reverted with the enforce commit
-     * ('enforce-revert'), kept because the enforce diff could not have caused it
-     * ('enforce-kept'), blocked by a spec-frozen path ('frozen-blocked'), a sibling's
-     * deliverable deleted and accepted ('cross-task-deletion'), or another task's
-     * pre-existing bug this one merely tripped over ('root-cause').
+     * loop then did with the WORK — accepted by a human ('accepted'), dismissed at
+     * the picker ('dismissed'), accepted unattended by yolo mode ('yolo-accepted'),
+     * reverted with the enforce commit ('enforce-revert'), kept because the enforce
+     * diff could not have caused it ('enforce-kept'), unreachable under the task's
+     * own spec ('spec-contradiction'), a sibling's deliverable deleted and accepted
+     * ('cross-task-deletion'), or another task's pre-existing bug this one merely
+     * tripped over ('root-cause').
      *
      * The ORIGIN is load-bearing, not a label: the final gate reports by class, and
      * an unattended auto-pick may never be recorded as the 'accepted' class, which
@@ -162,6 +176,16 @@ export interface GateDeps {
      * queues repairs exactly like /task-auto — only the plan mutation is the loop's.
      */
     recordRepairCandidate?: (cwd: string, candidate: RepairCandidate) => Promise<void>;
+    /**
+     * Close the open static debts naming a health command, stamped with the task
+     * whose verified work made that check pass — a health repair entry
+     * (health-repair.ts) going green. Returns the debts closed. Absent (tests) →
+     * nothing closes.
+     */
+    closeHealthDebts?: (cwd: string, command: string, resolvedBy: string) => Promise<{
+        taskId: string;
+        reason: string;
+    }[]>;
     /**
      * Paths the CURRENT task's own work touches — the AUTHORSHIP discriminator for
      * the root-cause channel: a FAIL blamed on a file this task edited may well be
@@ -261,38 +285,6 @@ export type GateResult = {
     ctx: ExtensionCommandContext;
     reason?: string;
 };
-/**
- * How many times a verify FAIL may be auto-fixed UNATTENDED (the research
- * recommended AUTOFIX, so pi re-runs the impl turn without prompting) before the
- * loop falls back to the human picker. Each AUTOFIX is a full implementation
- * re-run, so a non-converging loop must not run forever with nobody able to break
- * it — after this many consecutive auto attempts that still FAIL, the picker is
- * shown so a person can decide. A recommendation to ACCEPT always shows the picker
- * regardless of this count (blessing an artifact as-is is a human's call).
- */
-export declare const MAX_AUTO_AUTOFIX = 3;
-/** Which of the four disjoint branches sent a FAIL to the terminal YOLO ACCEPT. */
-export interface YoloAcceptContext {
-    /** Rule 5c: the spec-required check could not run (tooling absent). */
-    isUnobserved: boolean;
-    /** Cross-task contradiction: the repo-health fix needs a spec-frozen path. */
-    isFrozenBlocked: boolean;
-    /** What the resolution research recommended, when it was consulted at all. */
-    recommend: ResolutionOutcome['recommend'];
-    /** Unattended AUTOFIX attempts already spent on this task. */
-    autoFixCount: number;
-}
-/**
- * The reason an auto-ACCEPT is being written — NAMED, not assumed.
- *
- * Four disjoint branches reach the terminal auto-ACCEPT, and only ONE of them has
- * spent the autofix budget. An UNOBSERVED FAIL never consults the research; a
- * frozen-blocked one is a contradiction no re-run can resolve; an ACCEPT
- * recommendation can arrive with the budget untouched. A single "autofix budget
- * spent" line would be false on three of the four, and a durable trail that
- * misstates why a defect shipped reads as an exhausted fixer that never tried.
- */
-export declare function yoloAcceptReason(c: YoloAcceptContext): string;
 /**
  * Show the boxed two-choice picker after a verify FAIL and return what the user
  * decided. The model-recommended card is placed first so the renderer tints it
@@ -300,7 +292,9 @@ export declare function yoloAcceptReason(c: YoloAcceptContext): string;
  * clarify/grill dialog: the same SessionUI.ask races the local boxed picker against
  * a remote answer, with the two actions also surfaced as remote buttons.
  */
-export declare function askVerifyResolution(ctx: ExtensionCommandContext, title: string, failReason: string, rec: ResolutionOutcome): Promise<ResolutionChoice>;
+export declare function askVerifyResolution(ctx: ExtensionCommandContext, title: string, failReason: string, rec: ResolutionOutcome, 
+/** The repair ACCEPT would queue (a regressed health check), if any. */
+acceptQueues?: string): Promise<ResolutionChoice>;
 /**
  * Run the verify + enforce gates against a task's just-finished implementation.
  *
@@ -340,9 +334,9 @@ type VerifyGateStep = {
 };
 /**
  * The VERIFY resolution loop: run the task's verification against the finished
- * work, and negotiate a FAIL through the graduated ladder (bounded lint fix →
- * recommendation → unattended autofix → picker) until it verifies, is accepted,
- * or terminates.
+ * work, and carry out what gate-resolution.ts's decision table says to do with a
+ * FAIL (bounded lint fix first, then the table's autofix / accept / ask) until it
+ * verifies, is accepted, or terminates.
  *
  * Split from `runGatesForTask` at the single boolean that crosses to the ENFORCE
  * half (`cleanPass`). This loop has four terminal exits and carries the whole