@deftai/directive-core 0.97.0 → 0.98.1

package/dist/authz/classify.js

@@ -150,6 +150,158 @@ function hasGhApiPath(tokens, needle) {
  * active UAT they deny without a prior human grant — never empty → shell-op-unclassifiable fail-open.
  */
 const AUTHZ_MUTATING_SUBCOMMANDS = new Set(["grant", "uat-start", "uat-suspend", "revoke"]);
+/**
+ * Policy authority mutators that weaken merge / branch / directive gates (#3186).
+ * Classified as **settings** — agents must not self-serve these under active UAT.
+ */
+const POLICY_AUTHORITY_MUTATORS = new Set([
+    "allow-bot-merge",
+    "allow-direct-commits",
+    "disable-directive",
+    "enable-directive",
+]);
+/** Kill-switch / permanent opt-out basenames agents must not plant under UAT (#3186 / #3039). */
+const KILL_SWITCH_BASENAMES = [".deft-directive-disable", ".no-deft-directive"];
+/**
+ * Downloaders / decoders that can plant files without shell redirects (#3206).
+ * Not in INDIRECT_WRITE_BINS: those feed hasWriteShape and would classify bare
+ * `curl $URL` as a store write via opaque-expansion heuristics.
+ */
+const DOWNLOADER_DECODER_BINS = new Set(["curl", "wget", "xxd", "openssl"]);
+/**
+ * File destination flags for downloaders/decoders (#3206).
+ * normalizeToken lowercases, so wget `-O` and curl `-o` share `-o`.
+ */
+const DOWNLOADER_FILE_DEST_FLAGS = new Set([
+    "-o",
+    "--output",
+    "--output-document",
+    "-out",
+    "--out",
+]);
+/** Directory destination flags (curl --output-dir / wget -P); bin-scoped below. */
+const CURL_DIR_DEST_FLAGS = new Set(["--output-dir"]);
+const WGET_DIR_DEST_FLAGS = new Set(["-p", "--directory-prefix"]);
+/** Final path segment of a token (path-qualified bins / .exe). */
+function binBareName(token) {
+    const pathish = token.replace(/['"]/g, "").toLowerCase().replace(/\\/g, "/");
+    const base = pathish.includes("/") ? pathish.slice(pathish.lastIndexOf("/") + 1) : pathish;
+    return base.endsWith(".exe") ? base.slice(0, -4) : base;
+}
+/** True when token names a downloader/decoder bin (bare or path-qualified). */
+function isDownloaderDecoderBin(token) {
+    const n = normalizeToken(token);
+    if (n.startsWith("-"))
+        return false;
+    return DOWNLOADER_DECODER_BINS.has(binBareName(token));
+}
+function isDownloaderDestFlag(flag, bin) {
+    if (DOWNLOADER_FILE_DEST_FLAGS.has(flag))
+        return true;
+    if (bin === "curl" && CURL_DIR_DEST_FLAGS.has(flag))
+        return true;
+    if (bin === "wget" && WGET_DIR_DEST_FLAGS.has(flag))
+        return true;
+    return false;
+}
+/**
+ * Destinations from curl/wget/xxd/openssl via -o/--output/-O/-out/--output-dir/-P
+ * (separate, =value, or attached short form) and xxd -r path-like write positionals (#3206).
+ * openssl uses flags only (no positional dests — avoids treating -in paths as writes).
+ * O(n) token walk — no nested-quantifier regex on untrusted input.
+ */
+function downloaderDecoderDestinations(tokens) {
+    const dests = [];
+    let i = 0;
+    while (i < tokens.length) {
+        if (!isDownloaderDecoderBin(tokens[i])) {
+            i++;
+            continue;
+        }
+        const bin = binBareName(tokens[i]);
+        i++;
+        // xxd reverse mode writes; without -r, path positionals are dump inputs (read).
+        let xxdReverse = false;
+        while (i < tokens.length) {
+            const raw = tokens[i];
+            const n = normalizeToken(raw);
+            // New bare bin starts another command segment (not pathish ./wget operands).
+            if (!n.startsWith("-") &&
+                !raw.includes("/") &&
+                !raw.includes("\\") &&
+                isDownloaderDecoderBin(raw)) {
+                break;
+            }
+            if (bin === "xxd" && (n === "-r" || n === "--reverse")) {
+                xxdReverse = true;
+                i++;
+                continue;
+            }
+            // Skip openssl/xxd input flags + value so -in PATH is not a write dest.
+            if (n === "-in" || n === "--in" || n === "-inform" || n === "--inform") {
+                const next = tokens[i + 1];
+                if (next !== undefined && !String(next).startsWith("-")) {
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            // --flag=value (and rare -out=value)
+            if (n.includes("=") && (n.startsWith("-") || n.startsWith("--"))) {
+                const eq = raw.indexOf("=");
+                const flag = normalizeToken(raw.slice(0, eq));
+                if (isDownloaderDestFlag(flag, bin)) {
+                    dests.push(pathishToken(raw.slice(eq + 1)));
+                }
+                i++;
+                continue;
+            }
+            // Attached short: -oPATH / -OPATH (after lowercasing both are -opath…)
+            if (n.startsWith("-") && !n.startsWith("--") && n.length > 2) {
+                if (n.startsWith("-out") && n.length > 4 && !n.startsWith("-output")) {
+                    dests.push(pathishToken(raw.slice(4)));
+                    i++;
+                    continue;
+                }
+                if (n.startsWith("-o") && !n.startsWith("-out") && n.length > 2) {
+                    dests.push(pathishToken(raw.slice(2)));
+                    i++;
+                    continue;
+                }
+                // wget attached -Pdir
+                if (bin === "wget" && n.startsWith("-p") && n.length > 2 && !n.startsWith("-proxy")) {
+                    dests.push(pathishToken(raw.slice(2)));
+                    i++;
+                    continue;
+                }
+            }
+            // Separate value: -o PATH / --output PATH / -out PATH / --output-dir / -P
+            if (isDownloaderDestFlag(n, bin)) {
+                const next = tokens[i + 1];
+                if (next !== undefined && !String(next).startsWith("-")) {
+                    dests.push(pathishToken(next));
+                    i += 2;
+                    continue;
+                }
+                i++;
+                continue;
+            }
+            // xxd -r only: path-like write positionals (not http(s) URLs). openssl: flags only.
+            if (bin === "xxd" && xxdReverse && !n.startsWith("-")) {
+                const p = pathishToken(raw);
+                if ((p.includes("/") || p.startsWith(".") || p.includes("\\")) &&
+                    !p.startsWith("http:") &&
+                    !p.startsWith("https:") &&
+                    !p.startsWith("ftp:")) {
+                    dests.push(p);
+                }
+            }
+            i++;
+        }
+    }
+    return dests;
+}
 function authzSubcommandFromToken(token) {
     const t = normalizeToken(token);
     if (t.startsWith("authz:")) {
@@ -158,6 +310,14 @@ function authzSubcommandFromToken(token) {
     }
     return AUTHZ_MUTATING_SUBCOMMANDS.has(t) ? t : null;
 }
+function policyMutatorFromToken(token) {
+    const t = normalizeToken(token);
+    if (t.startsWith("policy:")) {
+        const sub = t.slice("policy:".length);
+        return POLICY_AUTHORITY_MUTATORS.has(sub) ? sub : null;
+    }
+    return POLICY_AUTHORITY_MUTATORS.has(t) ? t : null;
+}
 /**
  * Detect `deft|task|directive authz:grant` / `authz grant` (and wrappers) in shell tokens.
  * O(n) token walk — no nested-quantifier regex on untrusted input.
@@ -189,6 +349,273 @@ function hasAuthzMutatingCli(tokens) {
     }
     return false;
 }
+/**
+ * Detect `policy:allow-bot-merge` / `policy allow-direct-commits` / peers (#3186).
+ * O(n) token walk — no nested-quantifier regex on untrusted input.
+ */
+function hasPolicyAuthorityMutator(tokens) {
+    for (let i = 0; i < tokens.length; i++) {
+        const raw = tokens[i];
+        if (raw === undefined)
+            break;
+        const t = normalizeToken(raw);
+        if (policyMutatorFromToken(t) !== null && t.startsWith("policy:")) {
+            return true;
+        }
+        const isPolicyBin = t === "policy" ||
+            t.endsWith("/policy") ||
+            t.endsWith("\\policy") ||
+            t.endsWith("/policy.js") ||
+            t.endsWith("\\policy.js") ||
+            t.endsWith("/policy.ts") ||
+            t.endsWith("\\policy.ts");
+        if (!isPolicyBin)
+            continue;
+        const next = tokens[i + 1] !== undefined ? normalizeToken(tokens[i + 1]) : "";
+        if (policyMutatorFromToken(next) !== null)
+            return true;
+    }
+    return false;
+}
+/**
+ * Shell write targeting `.deft-directive-disable` / `.no-deft-directive` (#3186 / #3039).
+ * Planting the kill-switch under UAT would full-bypass subsequent gates without operator recovery.
+ */
+function hasKillSwitchShellWrite(command, tokens) {
+    const lower = command.toLowerCase().replace(/\\/g, "/");
+    let mentionsKill = false;
+    for (const name of KILL_SWITCH_BASENAMES) {
+        if (lower.includes(name)) {
+            mentionsKill = true;
+            break;
+        }
+    }
+    if (!mentionsKill)
+        return false;
+    // Redirect dest region after each `>` / `>>` (O(n)).
+    for (let i = 0; i < lower.length; i++) {
+        if (lower[i] !== ">")
+            continue;
+        let j = i + 1;
+        if (j < lower.length && lower[j] === ">")
+            j++;
+        let end = j;
+        while (end < lower.length &&
+            lower[end] !== "|" &&
+            lower[end] !== ";" &&
+            lower[end] !== "&" &&
+            lower[end] !== "\n") {
+            end++;
+        }
+        const dest = lower.slice(j, end);
+        for (const name of KILL_SWITCH_BASENAMES) {
+            if (dest.includes(name))
+                return true;
+        }
+    }
+    // Downloader/decoder destinations: curl -o .deft-directive-disable, wget -O, … (#3206).
+    for (const dest of downloaderDecoderDestinations(tokens)) {
+        for (const name of KILL_SWITCH_BASENAMES) {
+            if (dest.includes(name))
+                return true;
+        }
+    }
+    // Write/destructive bins with a kill-switch path argument (touch, New-Item, …).
+    const killWriteBins = new Set([
+        ...INDIRECT_WRITE_BINS,
+        "touch",
+        "new-item",
+        "ni",
+        "echo",
+        "printf",
+        "type",
+    ]);
+    for (let ti = 0; ti < tokens.length; ti++) {
+        if (!killWriteBins.has(normalizeToken(tokens[ti])))
+            continue;
+        for (let tj = ti + 1; tj < tokens.length; tj++) {
+            const p = pathishToken(tokens[tj]);
+            for (const name of KILL_SWITCH_BASENAMES) {
+                if (p.includes(name))
+                    return true;
+            }
+        }
+    }
+    // Bare `touch .deft-directive-disable` — first token may be touch, path later.
+    for (const t of tokens) {
+        const p = pathishToken(t);
+        for (const name of KILL_SWITCH_BASENAMES) {
+            // Exact basename or ends with /basename
+            if (p === name || p.endsWith(`/${name}`)) {
+                // Require some write shape (redirect already handled; touch/ni/echo/…)
+                if (hasWriteShape(command, tokens) ||
+                    lower.includes("touch") ||
+                    lower.includes("new-item")) {
+                    return true;
+                }
+            }
+        }
+    }
+    return false;
+}
+/**
+ * True when a token is a write-capable language/runtime interpreter (#3186).
+ * Matches bare names, versioned bins (`python3.11`), and path-qualified forms
+ * (`/usr/bin/python3`, `C:\Python311\python.exe`) — exact Set membership alone
+ * would fail-open on absolute/versioned paths (Greptile P1).
+ */
+function isProgrammaticWriteBinToken(token) {
+    const t = normalizeToken(token);
+    if (t.length === 0)
+        return false;
+    // Path-qualified: keep final path segment after / or \ (normalizeToken strips quotes only).
+    const pathish = token.replace(/['"]/g, "").toLowerCase().replace(/\\/g, "/");
+    const base = pathish.includes("/") ? pathish.slice(pathish.lastIndexOf("/") + 1) : t;
+    const bare = base.endsWith(".exe") ? base.slice(0, -4) : base;
+    if (bare === "python" ||
+        bare === "python3" ||
+        bare === "node" ||
+        bare === "nodejs" ||
+        bare === "perl" ||
+        bare === "ruby" ||
+        bare === "pwsh" ||
+        bare === "powershell") {
+        return true;
+    }
+    // Versioned: python3.11, python3.12, node18, …
+    if (bare.startsWith("python3.") || bare.startsWith("python2."))
+        return true;
+    if (/^python\d+(\.\d+)*$/.test(bare))
+        return true;
+    if (/^node\d+$/.test(bare))
+        return true;
+    return false;
+}
+/**
+ * True when `needle` occurs in `haystack` outside single/double-quoted regions (O(n)).
+ * Escaped quotes (`\'` / `\"`) stay inside the string. Used so `print('.write(')` is not
+ * a write API while `open(p,'w').write('x')` still matches `.write(` (Greptile conf residual).
+ */
+function includesOutsideQuotes(haystack, needle) {
+    if (needle.length === 0 || haystack.length < needle.length)
+        return false;
+    let inSingle = false;
+    let inDouble = false;
+    for (let i = 0; i < haystack.length; i++) {
+        const c = haystack[i];
+        if (c === "\\" && i + 1 < haystack.length && (inSingle || inDouble)) {
+            i++; // skip escaped char inside quotes
+            continue;
+        }
+        if (c === "'" && !inDouble) {
+            inSingle = !inSingle;
+            continue;
+        }
+        if (c === '"' && !inSingle) {
+            inDouble = !inDouble;
+            continue;
+        }
+        if (inSingle || inDouble)
+            continue;
+        if (haystack.startsWith(needle, i))
+            return true;
+    }
+    return false;
+}
+/**
+ * True when command uses a programmatic bin with a **write** API, optionally with
+ * path-obfuscation markers (base64/bytes/chr). Pure reads / print-only stay unclassifiable.
+ *
+ * Chosen rule (#3186): classify write-capable programmatic Shell as **settings** so
+ * active UAT fails closed (not shell-op-unclassifiable allow) even when the path is
+ * built at runtime without a literal `.deft/authz` substring. Outside UAT, evaluate
+ * still returns authz-inactive allow — classification alone is not a hard deny.
+ *
+ * Read-only `open(...).read()` does **not** count as writeish (Greptile P1).
+ * Quoted data containing `.write(` does **not** count (Greptile conf residual).
+ * Obfuscation alone without a write API does **not** classify (avoid deny on decode-only).
+ */
+function hasWriteCapableProgrammaticShell(command, tokens) {
+    let hasProg = false;
+    for (const t of tokens) {
+        if (isProgrammaticWriteBinToken(t)) {
+            hasProg = true;
+            break;
+        }
+    }
+    if (!hasProg)
+        return false;
+    const lower = command.toLowerCase();
+    // Shell wrappers put whole scripts in "…" after -c/-e, so long API names (writeFileSync)
+    // use full-string includes. Short ambiguous `.write(` uses quote-aware match so
+    // `print('.write(')` is not a write API (Greptile conf residual).
+    const writeApi = lower.includes("writefilesync") ||
+        lower.includes("writefile") ||
+        lower.includes("writetext") ||
+        lower.includes("set-content") ||
+        lower.includes("out-file") ||
+        lower.includes("fs.write") ||
+        lower.includes("createwritestream") ||
+        lower.includes("path.write(") ||
+        lower.includes("file.write(") ||
+        lower.includes("spurt") ||
+        lower.includes(">>") ||
+        lower.includes("unlink(") ||
+        lower.includes("rmsync") ||
+        lower.includes("rm_rf") ||
+        lower.includes("shutil.rmtree") ||
+        lower.includes("os.remove(") ||
+        lower.includes("os.unlink(") ||
+        lower.includes("fs.unlink") ||
+        lower.includes("fs.rm(") ||
+        lower.includes("fs.rmsync") ||
+        // Short `.write(` only counts outside quotes (avoids print('.write(') false positive).
+        // Also match when it appears after a shell -c/-e opening quote as code (common PoC shape):
+        // if the command has write mode open or other write API, those already hit above.
+        includesOutsideQuotes(lower, ".write(") ||
+        // Script body after -c/-e often sits in one double-quoted region: still detect `.write(`
+        // as code when paired with an assignment/call shape (f.write / .write(x)).
+        (lower.includes(".write(") &&
+            (lower.includes("open(") || lower.includes("=open") || lower.includes("fs.")));
+    // open(..., 'w' / "w" / 'a' / '>') — mode tokens are quoted; match on full command.
+    const openWriteMode = lower.includes("open(") &&
+        (lower.includes(",'w") ||
+            lower.includes(',"w') ||
+            lower.includes(", 'w") ||
+            lower.includes(', "w') ||
+            lower.includes(",'a") ||
+            lower.includes(',"a') ||
+            lower.includes(", 'a") ||
+            lower.includes(', "a') ||
+            lower.includes(",'>") ||
+            lower.includes(',">') ||
+            lower.includes(", '>") ||
+            lower.includes(', ">') ||
+            lower.includes("mode='w") ||
+            lower.includes('mode="w') ||
+            lower.includes("mode='a") ||
+            lower.includes('mode="a') ||
+            lower.includes("mode=w"));
+    const writeish = writeApi || openWriteMode;
+    // Path construction that hides the destination from literal classifiers.
+    const obfuscatedPath = lower.includes("base64") ||
+        lower.includes("fromcharcode") ||
+        lower.includes("bytes([") ||
+        lower.includes("bytearray") ||
+        lower.includes("buffer.from") ||
+        lower.includes("codecs.decode") ||
+        lower.includes("unhexlify") ||
+        lower.includes("fromhex") ||
+        lower.includes("string.fromcharcode") ||
+        lower.includes("atob(") ||
+        lower.includes("btoa(") ||
+        lower.includes("chr(");
+    // Fail-closed residual: write-ish programmatic shell (obfuscation alone not enough).
+    if (writeish)
+        return true;
+    void obfuscatedPath;
+    return false;
+}
 /**
  * Path-ish normalize: keep separators (do not strip `\` like normalizeToken).
  */
@@ -232,6 +659,11 @@ function hasAuthzDirShellWrite(command, tokens) {
                 return true;
         }
     }
+    // Downloader/decoder destinations under .deft/authz (#3206 residual after #3186).
+    for (const dest of downloaderDecoderDestinations(tokens)) {
+        if (dest.includes(".deft/authz"))
+            return true;
+    }
     return false;
 }
 /** Write/destructive shell bins (token match after normalizeToken). */
@@ -621,6 +1053,11 @@ export function classifyShellAuthzOps(command) {
         found.add("settings");
     if (hasAuthzDirShellWrite(cmd, tokens))
         found.add("settings");
+    // #3186: kill-switch plant + policy authority mutators → settings (UAT fail-closed).
+    if (hasKillSwitchShellWrite(cmd, tokens))
+        found.add("settings");
+    if (hasPolicyAuthorityMutator(tokens))
+        found.add("settings");
     // Split path write: `cd .deft && echo x > authz/state.json` OR `cd .deft/authz && echo x > state.json`
     // OR `cd .deft/authz && cp … grants/x` (write bin without redirect).
     // When the command cds into an authz path, any write shape is settings (relative dest has no "authz" text).
@@ -665,6 +1102,12 @@ export function classifyShellAuthzOps(command) {
     }
     if (hasIndirectAuthzStoreWrite(cmd, tokens))
         found.add("settings");
+    // #3186: programmatic write/obfuscated-path shells fail closed as settings (not unclassifiable allow).
+    // Always merge settings even when other ops already matched (e.g. `pytest && python -c '…write…'`)
+    // so a compound safe prefix cannot hide a write-capable residual (SLizard residual).
+    if (hasWriteCapableProgrammaticShell(cmd, tokens)) {
+        found.add("settings");
+    }
     return [...found];
 }
 /** Map a PreToolUse tool name + optional shell command to authz ops. */

package/dist/check/cached-orchestrator.d.ts

@@ -11,6 +11,11 @@ export interface CachedCheckOptions extends CheckOrchestratorSeams {
 /**
  * Run check gates sequentially with content-hash caching (#1713).
  * Falls back to fail-open execution for undeclared / non-cacheable gates.
+ *
+ * Gate order is fast-before-slow (#3188): non-suite gates complete (or fail)
+ * before any suite gate (`ts:check-lane` / vitest+coverage) is started. A
+ * non-zero exit aborts the loop immediately — the suite never starts after a
+ * fast-gate failure (observable via `onGateStart` / suite start log).
  */
 export declare function dispatchCachedTaskCheck(frameworkRoot: string, projectRoot: string, options?: CachedCheckOptions): number;
 //# sourceMappingURL=cached-orchestrator.d.ts.map

package/dist/check/cached-orchestrator.js

@@ -4,7 +4,7 @@ import { lintShippedRegistry, resolveTaskContract, runWithCache, } from "../cach
 import { readCorePackageVersion } from "../engine-version.js";
 import { evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, } from "./consumer-gate-integrity.js";
 import { resolveCheckTarget } from "./context.js";
-import { checkGateId, checkGateSpawnArgs, gatesForCheckTarget } from "./gate-lists.js";
+import { checkGateId, checkGateSpawnArgs, gatesForCheckTarget, isSuiteCheckGate, } from "./gate-lists.js";
 function captureSpawn(taskBin, args, opts) {
     const result = spawnSync(taskBin, args, {
         cwd: opts.cwd,
@@ -20,6 +20,11 @@ function captureSpawn(taskBin, args, opts) {
 /**
  * Run check gates sequentially with content-hash caching (#1713).
  * Falls back to fail-open execution for undeclared / non-cacheable gates.
+ *
+ * Gate order is fast-before-slow (#3188): non-suite gates complete (or fail)
+ * before any suite gate (`ts:check-lane` / vitest+coverage) is started. A
+ * non-zero exit aborts the loop immediately — the suite never starts after a
+ * fast-gate failure (observable via `onGateStart` / suite start log).
  */
 export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}) {
     const resolvedFramework = resolve(frameworkRoot);
@@ -53,6 +58,11 @@ export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}
     }
     for (const gateSpec of gates) {
         const gateId = checkGateId(gateSpec);
+        // #3188: log suite entry so operators/tests can prove fast failures never
+        // reach vitest+coverage (suite gates are ordered last in gate-lists).
+        if (isSuiteCheckGate(gateSpec)) {
+            process.stderr.write(`check: starting suite gate ${gateId} after fast preflight (#3188)\n`);
+        }
         options.onGateStart?.(gateId);
         const contract = resolveTaskContract(gateId);
         const taskArgs = checkGateSpawnArgs(gateSpec, taskfilePath);
@@ -78,7 +88,14 @@ export function dispatchCachedTaskCheck(frameworkRoot, projectRoot, options = {}
             },
         });
         options.onGateComplete?.(gateId, result.exitCode, result.fromCache);
+        // Fail-fast: do not start later gates (including suite) after a failure.
         if (result.exitCode !== 0) {
+            if (!isSuiteCheckGate(gateSpec)) {
+                const remaining = gates.some(isSuiteCheckGate)
+                    ? "skipping remaining gates including suite"
+                    : "skipping remaining gates";
+                process.stderr.write(`check: fast gate ${gateId} failed (exit ${result.exitCode}); ${remaining} (#3188)\n`);
+            }
             return result.exitCode;
         }
     }

package/dist/check/gate-lists.d.ts

@@ -12,6 +12,26 @@ export type CheckGateSpec = string | {
 export declare function checkGateId(spec: CheckGateSpec): string;
 /** Args for `task … --taskfile <path>` (optional `--` + public CLI flags). */
 export declare function checkGateSpawnArgs(spec: CheckGateSpec, taskfilePath: string): string[];
+/**
+ * Gates that own the long vitest+coverage (or equivalent) suite path.
+ * Shared `task check` composition runs every non-suite gate first so cheap
+ * failures never pay suite wall-clock (#3188). Release suite stamp/resume
+ * remains #3187 / release-scoped.
+ */
+export declare const SUITE_CHECK_GATE_IDS: readonly string[];
+export declare function isSuiteCheckGate(spec: CheckGateSpec | string): boolean;
+/**
+ * True when every suite gate appears after all non-suite gates (#3188).
+ * Empty lists and suite-only lists are valid; a non-suite after a suite is not.
+ */
+export declare function isFastBeforeSlowOrder(gates: readonly CheckGateSpec[]): boolean;
+/**
+ * Framework-source check composition (#1713 / #3188).
+ *
+ * Order contract: cheap preflight gates first; `ts:check-lane` (lint+build+
+ * vitest coverage suite) last so a stale cache / orphan-active / branch miss
+ * fails in seconds without starting the suite.
+ */
 export declare const FRAMEWORK_CHECK_GATES: readonly CheckGateSpec[];
 export declare const CONSUMER_CHECK_GATES: readonly CheckGateSpec[];
 export declare function gatesForCheckTarget(target: string): readonly CheckGateSpec[];

package/dist/check/gate-lists.js

@@ -11,23 +11,59 @@ export function checkGateSpawnArgs(spec, taskfilePath) {
     }
     return [task, "--taskfile", taskfilePath];
 }
+/**
+ * Gates that own the long vitest+coverage (or equivalent) suite path.
+ * Shared `task check` composition runs every non-suite gate first so cheap
+ * failures never pay suite wall-clock (#3188). Release suite stamp/resume
+ * remains #3187 / release-scoped.
+ */
+export const SUITE_CHECK_GATE_IDS = ["ts:check-lane"];
+export function isSuiteCheckGate(spec) {
+    const id = typeof spec === "string" ? spec : checkGateId(spec);
+    return SUITE_CHECK_GATE_IDS.includes(id);
+}
+/**
+ * True when every suite gate appears after all non-suite gates (#3188).
+ * Empty lists and suite-only lists are valid; a non-suite after a suite is not.
+ */
+export function isFastBeforeSlowOrder(gates) {
+    let sawSuite = false;
+    for (const gate of gates) {
+        if (isSuiteCheckGate(gate)) {
+            sawSuite = true;
+        }
+        else if (sawSuite) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Framework-source check composition (#1713 / #3188).
+ *
+ * Order contract: cheap preflight gates first; `ts:check-lane` (lint+build+
+ * vitest coverage suite) last so a stale cache / orphan-active / branch miss
+ * fails in seconds without starting the suite.
+ */
 export const FRAMEWORK_CHECK_GATES = [
-    "ts:check-lane",
+    // --- Fast preflight (seconds–few min) — #3188 ---
+    "verify:branch",
+    "verify:encoding",
+    "verify:cache-fresh",
+    "verify:orphan-active",
+    "verify:license-sync",
+    "verify:contract-drift",
     "toolchain:check",
     "verify:stubs",
     "verify:links",
     "verify:rule-ownership",
     "verify:biome-config",
     "verify:content-manifest",
-    "verify:license-sync",
     "verify:skill-external-fetch-gate",
-    "verify:contract-drift",
     "verify:cursor-tier1",
     "verify:openclaw-tier1",
     "verify:go-freeze",
     "verify:bridge-drift",
-    "verify:branch",
-    "verify:encoding",
     "verify:forward-coverage",
     // #3145: test/source boundary + approved-scope provenance + consumer gate composition
     "verify:test-boundary",
@@ -38,11 +74,9 @@ export const FRAMEWORK_CHECK_GATES = [
     "verify:scm-boundary",
     "verify:xbrief-drift",
     "verify:no-task-runtime",
-    "verify:cache-fresh",
     "verify:pack-drift",
     // Public surface for Taskfile verify-wip-cap-framework-self-check (#1124 / #2791)
     { task: "verify:wip-cap", args: ["--allow-over-cap"] },
-    "verify:orphan-active",
     "verify:agents-md-budget",
     // Public surfaces for internal eval-relocation framework shims (#2791)
     { task: "verify:eval-health-relocation", args: ["--base-ref", "origin/master"] },
@@ -51,14 +85,17 @@ export const FRAMEWORK_CHECK_GATES = [
     "codebase:validate-structure",
     "verify:codebase-map-fresh",
     "verify-strategy-output",
+    // --- Suite last: vitest + coverage via ts:check-lane (#3188) ---
+    "ts:check-lane",
 ];
 export const CONSUMER_CHECK_GATES = [
-    "doctor",
-    "toolchain:check-consumer",
+    // Cheap lifecycle / policy first (no suite co-list today; keep fail-fast order)
     "verify:branch",
     "verify:cache-fresh",
     "verify:wip-cap",
     "verify:orphan-active",
+    "doctor",
+    "toolchain:check-consumer",
     // #3145 enforcement trio (test placement, scope provenance, gate composition)
     "verify:test-boundary",
     "verify:scope-provenance",

package/dist/check/index.d.ts

@@ -1,6 +1,6 @@
 export { dispatchCachedTaskCheck } from "./cached-orchestrator.js";
 export { CHECK_GRAPH_REQUIRED_NAMESPACES, CONSUMER_GATE_INTEGRITY_RECOVERY, type ConsumerGateIntegrityFinding, type ConsumerGateIntegrityResult, type ConsumerGateIntegritySeams, checkGraphOptionalIncludeViolations, evaluateConsumerGateIntegrity, formatConsumerGateIntegrityFailure, gateLocalName, gateNamespace, includeTaskfileRel, parseTaskfileIncludes, requiredNamespacesForGates, taskDefinedInTaskfileYaml, } from "./consumer-gate-integrity.js";
-export { type CheckGateSpec, CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, } from "./gate-lists.js";
+export { type CheckGateSpec, CONSUMER_CHECK_GATES, checkGateId, checkGateSpawnArgs, FRAMEWORK_CHECK_GATES, gatesForCheckTarget, isFastBeforeSlowOrder, isSuiteCheckGate, SUITE_CHECK_GATE_IDS, } from "./gate-lists.js";
 export type { CheckOrchestratorOptions, CheckOrchestratorSeams } from "./orchestrator.js";
 export { dispatchTaskCheck, isFrameworkRepoRoot, isFrameworkSourceContext, resolveCheckTarget, } from "./orchestrator.js";
 export { detectTestRunner, type RunnerDetectResult, runnerDetectionTable, type TestRunnerKind, } from "./runner-detect.js";