@mjasnikovs/pi-task 0.17.10 → 0.17.12

package/dist/task/gate-deps.js

@@ -15,10 +15,11 @@
  */
 import * as fsp from 'node:fs/promises';
 import * as path from 'node:path';
-import { tasksDir, readTaskFile } from './task-io.js';
+import { tasksDir, readTaskFile, appendGateRecord } from './task-io.js';
 import { gitCommitAll, gitDropLastCommit } from './auto-commit.js';
 import { runGuidelineEnforcement, classifyEnforceChildFailure } from './enforce-guidelines.js';
 import { runWorkVerification, extractSpecForVerification } from './verify-work.js';
+import { runRepoHealthCheck } from './repo-health-check.js';
 import { researchResolution } from './verify-resolution.js';
 import { runWorker } from '../workers/pi-worker-core.js';
 import { formatLoopHint } from './child-runner.js';
@@ -95,6 +96,9 @@ export function buildGateDeps(params) {
     };
     return {
         runTask,
+        // Durable per-task gate trail: every verdict/decision lands in the task
+        // file's `## gates` section so gate behavior is auditable from artifacts.
+        record: (cwd2, taskId, line) => appendGateRecord(cwd2, taskId, line),
         commit: (cwd2, message) => getConfig().autoCommit ?
             gitCommitAll(cwd2, message, signal)
             : Promise.resolve({ committed: false, reason: 'auto-commit disabled' }),
@@ -195,7 +199,11 @@ export function buildGateDeps(params) {
                 cwd: cwd2,
                 signal,
                 spec,
-                runChild: makeGateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log')
+                runChild: makeGateChild(verifyCtx, cwd2, taskTitle, 'verify', 'verify-debug.log'),
+                // 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).
+                repoHealth: () => Promise.resolve(runRepoHealthCheck(cwd2))
             });
         },
         recommend: async (recCtx, cwd2, taskTitle, taskId, failReason) => {

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

@@ -0,0 +1,33 @@
+export interface HealthOutcome {
+    /** true → every discovered static check passed, or there was nothing to run.
+     *  false → a discovered command actually ran and exited non-zero. */
+    ok: boolean;
+    /** Human-readable reason. On a fail, names the exact command and exit code. */
+    reason: string;
+    /** Which manifest drove discovery, or null when none was found. */
+    ecosystem: string | null;
+}
+/** One discovered command: the binary and its args, run from the repo root. */
+export type HealthCommand = [bin: string, args: string[]];
+/**
+ * Discover the project's OWN whole-repo static-analysis commands. First manifest
+ * that exists wins; returns only the STATIC commands actually available for that
+ * ecosystem (never test/build/run). An empty list means "nothing static to run".
+ */
+export declare function discoverHealthCommands(cwd: string): {
+    ecosystem: string | null;
+    cmds: HealthCommand[];
+};
+/**
+ * Run the discovered static checks whole-repo and let the real exit codes decide.
+ * Deterministic and synchronous under the hood (a wrapper keeps the caller async).
+ *
+ *  - No manifest / no static command  → ok (nothing can regress).
+ *  - A command that CANNOT run (ENOENT / null exit — tool not installed) → skipped,
+ *    treated as an environment gap, not a fault.
+ *  - A command that ran and exited non-zero → the first such failure is returned.
+ *
+ * A generous per-command timeout guards against a wedged tool; a timeout is treated
+ * as an inconclusive skip, not a fault (it is an environment problem, not the code's).
+ */
+export declare function runRepoHealthCheck(cwd: string, timeoutMs?: number): HealthOutcome;

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

@@ -0,0 +1,122 @@
+/**
+ * repo-health-check — the deterministic, whole-repo half of the verify gate.
+ *
+ * The failure this closes (proven on the mx5 run): the verify gate ran only the
+ * task's OWN composed VERIFY block, and that block is authored per-task by the local
+ * model — so it is inconsistent. Some tasks lint the whole repo, some (TASK_0021)
+ * ship a VERIFY of `tsc --noEmit` ONLY, with no lint at all. A/B on the live model,
+ * 5 runs/arm on the real dirty tree: the tsc-only task false-PASSed 5/5 while
+ * `bun run lint` reported 11 errors. The model gate is only ever as good as the
+ * VERIFY block it happened to be handed.
+ *
+ * This check does NOT depend on that block. It discovers the project's OWN
+ * whole-repo static-analysis command (the one a fresh checkout / CI would run) and
+ * lets its REAL exit code decide — no model, so there is no per-file narrowing and
+ * no "those errors aren't in my files" gray area. A non-zero exit is a FAIL that the
+ * caller turns into the existing verify-FAIL outcome (→ the AUTOFIX / ACCEPT /
+ * dismiss picker; the user decides).
+ *
+ * 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 — running them here would re-introduce the false-FAIL that once wrongly blamed
+ * code for a missing DB. Static analysis is hermetic: it needs no network, no service,
+ * no fixtures, and it is exactly the class of the reported defect.
+ *
+ * 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
+ * command wired up. A tool that is simply not installed (ENOENT / null exit) is an
+ * environment gap, not a code fault, so that command is SKIPPED — only a command that
+ * actually ran and returned non-zero fails the check.
+ */
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+function packageScripts(cwd) {
+    try {
+        const j = JSON.parse(readFileSync(path.join(cwd, 'package.json'), 'utf8'));
+        return j.scripts ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Does the Makefile define a `<target>:` rule? (so `make <target>` won't error out) */
+function makeHasTarget(cwd, target) {
+    try {
+        const mk = readFileSync(path.join(cwd, 'Makefile'), 'utf8');
+        return new RegExp(`^${target}:`, 'm').test(mk);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Discover the project's OWN whole-repo static-analysis commands. First manifest
+ * that exists wins; returns only the STATIC commands actually available for that
+ * ecosystem (never test/build/run). An empty list means "nothing static to run".
+ */
+export function discoverHealthCommands(cwd) {
+    if (existsSync(path.join(cwd, 'package.json'))) {
+        const s = packageScripts(cwd);
+        const cmds = [];
+        // Only static-analysis scripts. `lint` commonly chains tsc (as in mx5's
+        // `prettier && eslint && tsc`), so a single `bun run lint` covers both.
+        for (const name of ['lint', 'typecheck']) {
+            if (s[name])
+                cmds.push(['bun', ['run', name]]);
+        }
+        return { ecosystem: 'package.json', cmds };
+    }
+    if (existsSync(path.join(cwd, 'Makefile'))) {
+        const cmds = [];
+        if (makeHasTarget(cwd, 'lint'))
+            cmds.push(['make', ['lint']]);
+        return { ecosystem: 'Makefile', cmds };
+    }
+    if (existsSync(path.join(cwd, 'Cargo.toml'))) {
+        return { ecosystem: 'Cargo.toml', cmds: [['cargo', ['clippy', '--quiet']]] };
+    }
+    if (existsSync(path.join(cwd, 'pyproject.toml'))) {
+        return { ecosystem: 'pyproject.toml', cmds: [['ruff', ['check', '.']]] };
+    }
+    if (existsSync(path.join(cwd, 'deno.json')) || existsSync(path.join(cwd, 'deno.jsonc'))) {
+        return { ecosystem: 'deno', cmds: [['deno', ['lint']]] };
+    }
+    if (existsSync(path.join(cwd, 'go.mod'))) {
+        return { ecosystem: 'go.mod', cmds: [['go', ['vet', './...']]] };
+    }
+    return { ecosystem: null, cmds: [] };
+}
+/**
+ * Run the discovered static checks whole-repo and let the real exit codes decide.
+ * Deterministic and synchronous under the hood (a wrapper keeps the caller async).
+ *
+ *  - No manifest / no static command  → ok (nothing can regress).
+ *  - A command that CANNOT run (ENOENT / null exit — tool not installed) → skipped,
+ *    treated as an environment gap, not a fault.
+ *  - A command that ran and exited non-zero → the first such failure is returned.
+ *
+ * A generous per-command timeout guards against a wedged tool; a timeout is treated
+ * as an inconclusive skip, not a fault (it is an environment problem, not the code's).
+ */
+export function runRepoHealthCheck(cwd, timeoutMs = 600_000) {
+    const { ecosystem, cmds } = discoverHealthCommands(cwd);
+    if (!ecosystem || cmds.length === 0) {
+        return { ok: true, reason: 'no repo-wide static-analysis command found', ecosystem };
+    }
+    for (const [bin, args] of cmds) {
+        const r = spawnSync(bin, args, { cwd, encoding: 'utf8', timeout: timeoutMs });
+        // Tool missing (ENOENT) or killed by timeout → cannot conclude; skip it.
+        if (r.error || r.status === null)
+            continue;
+        if (r.status !== 0) {
+            return {
+                ok: false,
+                reason: `\`${bin} ${args.join(' ')}\` exited ${r.status}`,
+                ecosystem
+            };
+        }
+    }
+    return { ok: true, reason: `${ecosystem}: static checks passed`, ecosystem };
+}

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

@@ -77,6 +77,16 @@ export interface GateDeps {
      * skips the revert and warns.
      */
     revert?: (cwd: string) => Promise<void>;
+    /**
+     * Append one line to the task's durable gate trail (`## gates` in the task
+     * file). Every gate outcome — each verify verdict, the user's FAIL resolution,
+     * the commit result, enforce mode + verdict, the differential guard's decision —
+     * is recorded so the sequence is auditable from artifacts alone (the mx5 audit
+     * could not tell WHY 10 of 18 tasks show no enforce run: verdicts lived only in
+     * terminal notifies). Best-effort: absent in tests → skipped; failures are
+     * swallowed by the implementation, never by this sequence.
+     */
+    record?: (cwd: string, taskId: string, line: string) => Promise<void>;
 }
 /** Inputs the sequence needs that vary per caller. */
 export interface GateParams {

package/dist/task/task-gates.js

@@ -34,6 +34,21 @@ export async function askVerifyResolution(ctx, title, failReason, rec) {
  */
 export async function runGatesForTask(ctxIn, deps, p) {
     let active = ctxIn;
+    // Durable per-task gate trail — every outcome below is also appended to the
+    // task file so the sequence is auditable from artifacts alone. Best-effort.
+    const rec = async (line) => {
+        try {
+            await deps.record?.(p.cwd, p.taskId, line);
+        }
+        catch {
+            // recording must never break the gate sequence
+        }
+    };
+    const verdictLine = (v) => v.ok ?
+        v.reason ?
+            `verify: PASS (${v.reason})`
+            : 'verify: PASS'
+        : `verify: FAIL — ${v.reason ?? 'did not verify'}`;
     // GATE: actually RUN the task's verification against the just-finished work
     // BEFORE it is checked off or committed. Whether this produced a GENUINE clean
     // pass (a real signal ran and the work met it) also decides how the enforce pass
@@ -44,24 +59,29 @@ export async function runGatesForTask(ctxIn, deps, p) {
     if (deps.verify) {
         active.ui.notify(`${p.tag}: verifying "${p.title}"…`, 'info');
         let verified = await deps.verify(active, p.cwd, p.title, p.taskId);
+        await rec(verdictLine(verified));
         // A FAIL no longer dead-stops: offer the boxed AUTOFIX / ACCEPT / dismiss
         // picker. The USER always decides; AUTOFIX loops straight back to the gate
         // as many times as they keep choosing it (no attempt cap).
         while (!verified.ok) {
             const failReason = verified.reason ?? 'did not verify';
-            const rec = deps.recommend ?
+            const recOutcome = deps.recommend ?
                 await deps.recommend(active, p.cwd, p.title, p.taskId, failReason)
                 : { recommend: 'autofix', rationale: failReason };
-            const choice = await askVerifyResolution(active, p.title, failReason, rec);
+            await rec(`resolution: recommended ${recOutcome.recommend.toUpperCase()}`);
+            const choice = await askVerifyResolution(active, p.title, failReason, recOutcome);
             if (choice.action === 'cancel') {
+                await rec('resolution: user dismissed the verify-FAIL picker — paused');
                 return { kind: 'paused', ctx: active, reason: failReason };
             }
             if (choice.action === 'accept') {
+                await rec('resolution: user ACCEPTED the work despite verify FAIL');
                 active.ui.notify(`${p.tag}: accepted "${p.title}" despite verify FAIL (${failReason.slice(0, 120)}) — proceeding.`, 'warning');
                 break;
             }
             // AUTOFIX: re-run the implementation turn with the failure (and any typed
             // guidance) prepended as a RE-ATTEMPT banner, then re-verify.
+            await rec('resolution: user chose AUTOFIX — re-running the implementation turn');
             active.ui.notify(`${p.tag}: autofixing "${p.title}"…`, 'info');
             const fixInstruction = choice.guidance ? `${failReason}\n\nUser guidance: ${choice.guidance}` : failReason;
             const fixRes = await deps.runTask(active, p.cwd, p.title, {
@@ -78,6 +98,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 return { kind: 'failed', ctx: active, reason: fixRes.reason };
             // Resume reuses the same inner task id, so p.taskId is stable.
             verified = await deps.verify(active, p.cwd, p.title, p.taskId);
+            await rec(verdictLine(verified));
         }
         // Loop exited because the work verified OR the user accepted the artifact. A
         // genuine clean pass is ok===true with NO reason; a no-op pass or an
@@ -91,9 +112,11 @@ export async function runGatesForTask(ctxIn, deps, p) {
     // so a passing task is durably recorded no matter what enforcement later finds.
     const commit = await deps.commit(p.cwd, `task: ${p.title} (${p.taskId})`);
     if (commit.committed) {
+        await rec('commit: task snapshot committed');
         active.ui.notify(`${p.tag}: committed "${p.title}".`, 'info');
     }
     else {
+        await rec(`commit: skipped (${commit.reason ?? 'unknown'})`);
         active.ui.notify(`${p.tag}: not committed (${commit.reason ?? 'unknown'}) — continuing.`, 'warning');
     }
     // With the task committed, hold its work to AGENTS.md / CLAUDE.md — but as a step
@@ -106,6 +129,7 @@ export async function runGatesForTask(ctxIn, deps, p) {
             `${p.tag}: enforcing AGENTS.md/CLAUDE.md on "${p.title}"…`
             : `${p.tag}: reviewing "${p.title}" against AGENTS.md/CLAUDE.md (no verify signal — report only)…`, 'info');
         const verdict = await deps.enforce(active, p.cwd, p.title, mode);
+        await rec(`enforce(${mode}): ${verdict.ok ? `clean${verdict.reason ? ` (${verdict.reason})` : ''}` : (verdict.reason ?? 'not clean')}`);
         if (!verdict.ok) {
             active.ui.notify(`${p.tag}: guideline ${mode === 'edit' ? 'enforcement' : 'review'} on "${p.title}" — ${verdict.reason ?? 'not clean'} — continuing.`, 'warning');
         }
@@ -122,14 +146,24 @@ export async function runGatesForTask(ctxIn, deps, p) {
                 if (!after.ok) {
                     if (deps.revert)
                         await deps.revert(p.cwd);
+                    await rec(`enforce: fixes committed but re-verify FAILED (${(after.reason ?? 'now fails').slice(0, 200)}) — ${deps.revert ? 'REVERTED' : 'left in place (no revert available)'}`);
                     active.ui.notify(`${p.tag}: guideline fixes regressed verification on "${p.title}" (${(after.reason ?? 'now fails').slice(0, 120)}) — ${deps.revert ? 'reverted them, kept the verified work' : 'left in place (no revert available)'}.`, 'warning');
                 }
                 else {
+                    await rec('enforce: fixes committed — re-verify PASS, kept');
                     active.ui.notify(`${p.tag}: committed guideline fixes for "${p.title}".`, 'info');
                 }
             }
+            else {
+                await rec('enforce(edit): no fixes to commit');
+            }
         }
         // 'flag' mode makes no edits — nothing to commit or revert.
     }
+    else if (deps.enforce) {
+        // deps.enforce wired but nothing was committed this round — record the skip
+        // so a missing enforce run is explainable from the trail (mx5 audit gap).
+        await rec('enforce: skipped (nothing committed this round)');
+    }
     return { kind: 'done', ctx: active };
 }

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

@@ -21,5 +21,14 @@ export declare function writeTaskFile(cwd: string, fm: TaskFrontMatter, body: st
 export declare function updateTaskFrontMatter(cwd: string, id: string, patch: Partial<TaskFrontMatter>): Promise<void>;
 export declare function readSection(cwd: string, id: string, heading: string): Promise<string | null>;
 export declare function setTaskSection(cwd: string, id: string, heading: string, content: string): Promise<void>;
+/**
+ * Append one timestamped line to the task's `## gates` section — the durable
+ * per-task trail of gate outcomes (verify verdicts, enforce mode/verdict, commit
+ * results). Motivated by the mx5 audit: verdict text lived only in memory and
+ * terminal notifies, so "did enforce run for this task, and in which mode?" was
+ * unanswerable from artifacts. Best-effort by design: a failure to record must
+ * never break the gate sequence, so all errors are swallowed.
+ */
+export declare function appendGateRecord(cwd: string, id: string, line: string): Promise<void>;
 /** Remove a section (heading + body) if present; a no-op when it's absent. */
 export declare function removeTaskSection(cwd: string, id: string, heading: string): Promise<void>;

package/dist/task/task-io.js

@@ -112,6 +112,25 @@ export async function setTaskSection(cwd, id, heading, content) {
     }
     await writeTaskFile(cwd, { ...frontMatter, updated_at: new Date().toISOString() }, next);
 }
+/**
+ * Append one timestamped line to the task's `## gates` section — the durable
+ * per-task trail of gate outcomes (verify verdicts, enforce mode/verdict, commit
+ * results). Motivated by the mx5 audit: verdict text lived only in memory and
+ * terminal notifies, so "did enforce run for this task, and in which mode?" was
+ * unanswerable from artifacts. Best-effort by design: a failure to record must
+ * never break the gate sequence, so all errors are swallowed.
+ */
+export async function appendGateRecord(cwd, id, line) {
+    try {
+        const stamp = new Date().toISOString();
+        const entry = `- ${stamp} ${line.replace(/\s*\n\s*/g, ' ').trim()}`;
+        const existing = await readSection(cwd, id, 'gates');
+        await setTaskSection(cwd, id, 'gates', existing ? `${existing}\n${entry}` : entry);
+    }
+    catch {
+        // Recording is observability, not control flow — never propagate.
+    }
+}
 /** Remove a section (heading + body) if present; a no-op when it's absent. */
 export async function removeTaskSection(cwd, id, heading) {
     const { frontMatter, body } = await readTaskFile(cwd, id);

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

@@ -57,6 +57,18 @@ export interface VerificationDeps {
     /** Runs the verification child and returns its assistant text. Injected so
      *  the orchestrator wires the real child runner and tests use a fake. */
     runChild: (tools: string, prompt: string, signal?: AbortSignal) => Promise<string>;
+    /**
+     * DETERMINISTIC whole-repo static-analysis gate (see repo-health-check.ts). Runs
+     * the project's OWN lint/typecheck command and lets its real exit code decide —
+     * independent of the model-authored VERIFY block, so a repo-wide lint failure can
+     * never be narrowed away to "not my files". A non-zero result short-circuits to a
+     * FAIL (the existing verify-FAIL outcome → the AUTOFIX/ACCEPT/dismiss picker).
+     * Injected so tests fake it; ABSENT → skipped (a pass), keeping the pass path a
+     * pure no-op for callers/tests that do not wire it. */
+    repoHealth?: () => Promise<{
+        ok: boolean;
+        reason: string;
+    }>;
 }
 /**
  * Run the verification pass for one task. A missing spec is a pass. Otherwise run

package/dist/task/verify-work.js

@@ -39,6 +39,20 @@
  * genuinely-broken shipped build FAILs 3/3, and a genuine external-service gap — which
  * the OLD prompt wrongly blamed on the code 3/3 — now correctly PASSes 3/3.
  *
+ * The sibling failure class is GREP-THEATER (mx5 run 2, TASK_0002): the composed VERIFY
+ * block was grep-only, so the child "verified" a schema.sql containing INVALID SQL by
+ * grepping for its own broken text — while a live PostgreSQL sat reachable in the same
+ * container, never touched. The prompt now (a) says a grep-only VERIFY block does not cap
+ * the obligation to execute/apply an executable artifact, and (b) requires PROBING a
+ * declared external service before invoking the absent-service exception — reachable ⇒
+ * the real verification must run against it. A/B on the faithful fixture (invalid
+ * `generate always as` schema, grep-only VERIFY, unadvertised trust-auth PostgreSQL on
+ * the default port, DATABASE_URL unset — exactly the mx5 shape): old prompt false-PASSed
+ * 4/5; new prompt FAILed 5/5, each naming the real syntax error. Guards: explicit-URL
+ * variant old 5/5 / new 5/5 correct-FAIL (no regression), valid schema 3/3 PASS (no
+ * paranoia), unreachable-DB 2/3 PASS via the env-gap exception + 1 conservative FAIL
+ * that still named the genuine SQL defect (safe direction — only false-PASS trashes work).
+ *
  * It runs as a GATE right after the implementation turn, BEFORE the task is
  * checked off or committed. A FAIL stops the /task-auto run exactly like an
  * implementation failure: the task is left unchecked and uncommitted so
@@ -138,18 +152,31 @@ export function buildVerifyPrompt(spec) {
         '3. Presence of a token / directive / string in a SOURCE file is NOT verification.',
         '   Judge the produced artifact and the real runtime behavior. A raw build directive',
         '   that SURVIVES into the built output means the build never ran — that is a FAIL.',
+        "   The spec's VERIFY block does not cap this obligation: if that block only greps or",
+        '   reads source files but the deliverable can be EXECUTED or APPLIED on this machine',
+        '   (a script, a schema, a server, a config a tool can load), you must ALSO execute or',
+        '   apply it and judge the real result. Grep-only checks passing while the artifact was',
+        '   never executed is NOT a PASS — a static match cannot prove an artifact works, only',
+        '   running it can.',
         '',
         '4. Treat the ACCEPTANCE criteria as the bar. If a command fails, or its real output',
         '   contradicts an ACCEPTANCE criterion, the work has NOT verified.',
         '',
         '5. The ONLY thing you may assume is already provided is a genuinely EXTERNAL running',
         '   service or network resource (a database server, an API host) that the project',
-        '   documents as a prerequisite. If a command fails purely because such an external',
-        '   service is ABSENT from this machine — and NOT because the project misconfigures',
-        '   how it connects — note that as an environment gap and judge the rest; do not fail',
-        '   the code for it. But a command that fails because of how the PROJECT ITSELF is',
-        '   wired (config it owns but does not load, a wrong default, a command that cannot',
-        '   run unaided) is a defect, not an environment gap.',
+        '   documents as a prerequisite. Before you rely on that assumption, PROBE for the',
+        '   service with a cheap real check using the connection details the project/spec',
+        '   already declares (attempt the connection: pg_isready, a client one-liner, curl',
+        '   with a short timeout). If the probe shows the service IS reachable, the exception',
+        '   does NOT apply — you must run the real verification against it (apply the schema,',
+        '   run the suite, hit the endpoint) and judge the real result; falling back to static',
+        '   checks with the service available is NOT verification. Only if a command fails',
+        '   purely because such an external service is genuinely ABSENT from this machine —',
+        '   and NOT because the project misconfigures how it connects — note that as an',
+        '   environment gap and judge the rest; do not fail the code for it. But a command',
+        '   that fails because of how the PROJECT ITSELF is wired (config it owns but does',
+        '   not load, a wrong default, a command that cannot run unaided) is a defect, not an',
+        '   environment gap.',
         '',
         '6. If the spec legitimately has no runnable verification (a pure docs / config change',
         '   with nothing to build or run), validating it cleanly is a PASS.',
@@ -187,6 +214,17 @@ export function parseVerifyVerdict(text) {
  * USER_CANCELLED handler reports a clean "cancelled — resume").
  */
 export async function runWorkVerification(deps) {
+    // DETERMINISTIC gate FIRST: run the project's own whole-repo static analysis and
+    // let its exit code decide, before spending a model turn. This catches the class
+    // the model gate misses — a task whose composed VERIFY block never lints (proven
+    // 5/5 false-PASS live) — because it does not depend on that block. A fail is the
+    // ordinary verify-FAIL outcome, so it flows into the existing resolution picker.
+    // Absent dep, or a no-op result (no tooling to run), falls through to the model.
+    if (deps.repoHealth) {
+        const h = await deps.repoHealth();
+        if (!h.ok)
+            return { ok: false, reason: `repo health: ${h.reason}` };
+    }
     if (!deps.spec || deps.spec.trim().length === 0) {
         return { ok: true, reason: 'no spec to verify' };
     }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mjasnikovs/pi-task",
-    "version": "0.17.10",
+    "version": "0.17.12",
     "description": "Deterministic spec-orchestration for local models, with a bundled real-time remote web view and web/docs/fetch/worker subagent tools.",
     "type": "module",
     "main": "./dist/index.js",