@deftai/directive-core 0.66.2 → 0.67.0

package/dist/render/project-render.d.ts

@@ -1,4 +1,11 @@
+import { LEGACY_INFO_ROOT_KEY, MIGRATED_INFO_ROOT_KEY } from "../xbrief-migrate/constants.js";
 type JsonObject = Record<string, unknown>;
+/** PROJECT-DEFINITION artifact shape (filename + envelope key + emitted version). */
+interface ProjectDefinitionLayout {
+    readonly filename: string;
+    readonly infoRootKey: typeof MIGRATED_INFO_ROOT_KEY | typeof LEGACY_INFO_ROOT_KEY;
+    readonly infoVersion: string;
+}
 /** Durable review state for PROJECT-DEFINITION narrative staleness (#640). */
 export interface StalenessReviewMetadata {
     /** ISO-8601 UTC when narratives were last reviewed/acknowledged. */
@@ -24,12 +31,19 @@ export declare function buildStalenessAcknowledgement(completedItems: readonly L
     existing?: StalenessReviewMetadata | null;
 }): StalenessReviewMetadata;
 export declare function computeStalenessFlags(narratives: Record<string, string>, completedItems: readonly LifecycleItem[], review?: StalenessReviewMetadata | null): string[];
-export declare function createSkeleton(items: LifecycleItem[], now: string): JsonObject;
+export declare function createSkeleton(items: LifecycleItem[], now: string, layout: ProjectDefinitionLayout): JsonObject;
 export interface RenderProjectOptions {
     readonly now?: Date;
 }
 export type RenderProjectResult = readonly [boolean, string];
-/** Regenerate PROJECT-DEFINITION.vbrief.json (mirrors ``scripts/project_render.render_project_definition``). */
+/**
+ * Regenerate the PROJECT-DEFINITION artifact for `vbriefDir`.
+ *
+ * Layout-aware (#2149): on a migrated `xbrief/` root it targets
+ * `PROJECT-DEFINITION.xbrief.json` with an `xBRIEFInfo` envelope; on a legacy `vbrief/`
+ * root it keeps `PROJECT-DEFINITION.vbrief.json` + `vBRIEFInfo`.
+ * (Mirrors ``scripts/project_render.render_project_definition``.)
+ */
 export declare function renderProjectDefinition(vbriefDir: string, options?: RenderProjectOptions): RenderProjectResult;
 /**
  * Mark current completed scopes as reviewed for PROJECT-DEFINITION narratives.

package/dist/render/project-render.js

@@ -1,10 +1,34 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { basename, join, resolve } from "node:path";
+import { hasArtifactSuffix, resolveLifecycleRoot, stripArtifactSuffix } from "../layout/resolve.js";
 import { EMITTED_VBRIEF_VERSION } from "../vbrief-build/constants.js";
 import { deriveRegistryItemStatus, registryMetadataReferencesFromScope, } from "../vbrief-validate/registry-status.js";
+import { LEGACY_ARTIFACT_SUFFIX, LEGACY_INFO_ROOT_KEY, MIGRATED_ARTIFACT_DIR, MIGRATED_ARTIFACT_SUFFIX, MIGRATED_INFO_ROOT_KEY, VBRIEF_VERSION, } from "../xbrief-migrate/constants.js";
 import { PROJECT_LIFECYCLE_FOLDERS, SKELETON_NARRATIVES } from "./constants.js";
 import { splitCamel, splitWords } from "./text-utils.js";
+/**
+ * Resolve the PROJECT-DEFINITION artifact shape for a lifecycle root directory.
+ *
+ * The decision is STRUCTURAL and keyed on the lifecycle root directory name -- the
+ * same signal `resolveLifecycleLayout` / `resolveLifecycleRoot` produce, so ingest and
+ * render never diverge (#2149). A migrated `xbrief/` root gets `PROJECT-DEFINITION.xbrief.json`
+ * + `xBRIEFInfo`; a legacy `vbrief/` root keeps `PROJECT-DEFINITION.vbrief.json` + `vBRIEFInfo`.
+ * This prevents render from writing a legacy-named/enveloped artifact into a migrated tree.
+ */
+function resolveProjectDefinitionLayout(vbriefDir) {
+    const migrated = basename(vbriefDir) === MIGRATED_ARTIFACT_DIR;
+    return migrated
+        ? {
+            filename: `PROJECT-DEFINITION${MIGRATED_ARTIFACT_SUFFIX}`,
+            infoRootKey: MIGRATED_INFO_ROOT_KEY,
+            infoVersion: VBRIEF_VERSION,
+        }
+        : {
+            filename: `PROJECT-DEFINITION${LEGACY_ARTIFACT_SUFFIX}`,
+            infoRootKey: LEGACY_INFO_ROOT_KEY,
+            infoVersion: EMITTED_VBRIEF_VERSION,
+        };
+}
 export function scanLifecycleFolders(vbriefDir) {
     const items = [];
     for (const folderName of PROJECT_LIFECYCLE_FOLDERS) {
@@ -25,11 +49,11 @@ export function scanLifecycleFolders(vbriefDir) {
             try {
                 const data = JSON.parse(readFileSync(full, "utf8"));
                 const plan = (data.plan ?? {});
-                const title = String(plan.title ?? vbriefFile.replace(/\.vbrief\.json$/, ""));
+                const title = String(plan.title ?? stripArtifactSuffix(vbriefFile));
                 const status = deriveRegistryItemStatus(plan.status, folderName);
                 const references = registryMetadataReferencesFromScope(plan.references);
                 const item = {
-                    id: vbriefFile.replace(/\.vbrief\.json$/, "").replace(/\.vbrief$/, ""),
+                    id: stripArtifactSuffix(vbriefFile),
                     title,
                     status,
                     metadata: {
@@ -44,7 +68,7 @@ export function scanLifecycleFolders(vbriefDir) {
             }
             catch {
                 items.push({
-                    id: vbriefFile.replace(/\.vbrief\.json$/, "").replace(/\.vbrief$/, ""),
+                    id: stripArtifactSuffix(vbriefFile),
                     title: `[unreadable] ${vbriefFile}`,
                     status: "draft",
                     metadata: {
@@ -136,12 +160,12 @@ export function computeStalenessFlags(narratives, completedItems, review = null)
     const pending = unacknowledgedCompletedItems(completedItems, review);
     return flagStaleNarratives(narratives, pending);
 }
-export function createSkeleton(items, now) {
+export function createSkeleton(items, now, layout) {
     const completedItems = items.filter((i) => i.status === "completed");
     const stalenessFlags = computeStalenessFlags({ ...SKELETON_NARRATIVES }, completedItems);
     return {
-        vBRIEFInfo: {
-            version: EMITTED_VBRIEF_VERSION,
+        [layout.infoRootKey]: {
+            version: layout.infoVersion,
             description: "Project definition -- synthesized gestalt of the project",
             created: now,
             updated: now,
@@ -155,11 +179,19 @@ export function createSkeleton(items, now) {
         },
     };
 }
-/** Regenerate PROJECT-DEFINITION.vbrief.json (mirrors ``scripts/project_render.render_project_definition``). */
+/**
+ * Regenerate the PROJECT-DEFINITION artifact for `vbriefDir`.
+ *
+ * Layout-aware (#2149): on a migrated `xbrief/` root it targets
+ * `PROJECT-DEFINITION.xbrief.json` with an `xBRIEFInfo` envelope; on a legacy `vbrief/`
+ * root it keeps `PROJECT-DEFINITION.vbrief.json` + `vBRIEFInfo`.
+ * (Mirrors ``scripts/project_render.render_project_definition``.)
+ */
 export function renderProjectDefinition(vbriefDir, options = {}) {
     const nowDate = options.now ?? new Date();
     const now = nowDate.toISOString().replace(/\.\d{3}Z$/, "Z");
-    const projectDefPath = join(vbriefDir, "PROJECT-DEFINITION.vbrief.json");
+    const layout = resolveProjectDefinitionLayout(vbriefDir);
+    const projectDefPath = join(vbriefDir, layout.filename);
     const items = scanLifecycleFolders(vbriefDir);
     const createdNew = !existsSync(projectDefPath);
     let projectDef;
@@ -172,10 +204,11 @@ export function renderProjectDefinition(vbriefDir, options = {}) {
         }
         const plan = (projectDef.plan ?? {});
         plan.items = items;
-        if (typeof projectDef.vBRIEFInfo !== "object" || projectDef.vBRIEFInfo === null) {
-            projectDef.vBRIEFInfo = {};
+        if (typeof projectDef[layout.infoRootKey] !== "object" ||
+            projectDef[layout.infoRootKey] === null) {
+            projectDef[layout.infoRootKey] = {};
         }
-        projectDef.vBRIEFInfo.updated = now;
+        projectDef[layout.infoRootKey].updated = now;
         const narratives = typeof plan.narratives === "object" &&
             plan.narratives !== null &&
             !Array.isArray(plan.narratives)
@@ -194,7 +227,7 @@ export function renderProjectDefinition(vbriefDir, options = {}) {
         projectDef.plan = plan;
     }
     else {
-        projectDef = createSkeleton(items, now);
+        projectDef = createSkeleton(items, now, layout);
     }
     mkdirSync(vbriefDir, { recursive: true });
     writeFileSync(projectDefPath, `${JSON.stringify(projectDef, null, 2)}\n`, "utf8");
@@ -202,7 +235,7 @@ export function renderProjectDefinition(vbriefDir, options = {}) {
     const planMeta = (projectDef.plan?.metadata ?? {});
     const flagCount = Array.isArray(planMeta.staleness_flags) ? planMeta.staleness_flags.length : 0;
     const action = createdNew ? "created" : "updated";
-    const parts = [`✓ PROJECT-DEFINITION.vbrief.json ${action} (${itemCount} scope items)`];
+    const parts = [`✓ ${layout.filename} ${action} (${itemCount} scope items)`];
     if (flagCount > 0)
         parts.push(`⚠ ${flagCount} staleness flag(s) -- agent review recommended`);
     return [true, parts.join("\n")];
@@ -216,7 +249,8 @@ export function renderProjectDefinition(vbriefDir, options = {}) {
 export function acknowledgeProjectDefinitionStaleness(vbriefDir, options = {}) {
     const nowDate = options.now ?? new Date();
     const now = isoTimestamp(nowDate);
-    const projectDefPath = join(vbriefDir, "PROJECT-DEFINITION.vbrief.json");
+    const layout = resolveProjectDefinitionLayout(vbriefDir);
+    const projectDefPath = join(vbriefDir, layout.filename);
     if (!existsSync(projectDefPath)) {
         return [false, `✗ ${projectDefPath} not found — run project:render first`];
     }
@@ -245,10 +279,11 @@ export function acknowledgeProjectDefinitionStaleness(vbriefDir, options = {}) {
         ? plan.narratives
         : {};
     planMetadata.staleness_flags = computeStalenessFlags(narratives, completedItems, parseStalenessReview(planMetadata));
-    if (typeof projectDef.vBRIEFInfo !== "object" || projectDef.vBRIEFInfo === null) {
-        projectDef.vBRIEFInfo = {};
+    if (typeof projectDef[layout.infoRootKey] !== "object" ||
+        projectDef[layout.infoRootKey] === null) {
+        projectDef[layout.infoRootKey] = {};
     }
-    projectDef.vBRIEFInfo.updated = now;
+    projectDef[layout.infoRootKey].updated = now;
     projectDef.plan = plan;
     writeFileSync(projectDefPath, `${JSON.stringify(projectDef, null, 2)}\n`, "utf8");
     const ackCount = completedItems.length;
@@ -280,9 +315,7 @@ export function main(argv) {
         process.stderr.write("Usage: project-render [--acknowledge-staleness] [--project-root <dir>] [vbrief_dir]\n");
         return 2;
     }
-    const vbriefDir = projectRoot !== undefined
-        ? resolveLifecycleRoot(resolve(projectRoot))
-        : (positional[0] ?? "vbrief");
+    const vbriefDir = positional[0] ?? resolveLifecycleRoot(resolve(projectRoot !== undefined ? projectRoot : "."));
     const [ok, message] = acknowledge
         ? acknowledgeProjectDefinitionStaleness(vbriefDir)
         : renderProjectDefinition(vbriefDir);

package/dist/swarm/launch.d.ts

@@ -68,6 +68,12 @@ export interface LaunchArgs {
     readinessGate?: ReadinessGateFn;
     worktreeResolver?: WorktreeResolverFn;
     runtimeAuthProbe?: RuntimeAuthProbeFn;
+    /**
+     * Injection seam for the routing-provider environment lookup, mirroring
+     * `resolveRoutingPath`'s `environ` parameter (#1877 Greptile follow-up).
+     * Defaults to `process.env` when unset.
+     */
+    environ?: NodeJS.ProcessEnv;
 }
 export declare function swarmLaunch(args: LaunchArgs): {
     exitCode: number;

package/dist/swarm/launch.js

@@ -8,7 +8,7 @@ import { issueNumbersFromPlan, scopeMetadataRank } from "../triage/queue/scope-w
 import { selectionOrderingKey } from "../triage/queue/selection.js";
 import { DEFAULT_BASE_BRANCH, EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK, GATE_ADVISE, GATE_ENFORCE, LEAF_CODING_WORKER_ROLE, } from "./constants.js";
 import { readinessReport } from "./readiness.js";
-import { dispatchProviderFromRuntime, loadRoutingFile, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
+import { loadRoutingFile, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
 import { dispatchProviderFor, enforceSubagentBackendPolicy } from "./subagent-backend.js";
 import { resolveWorktreeMap } from "./worktrees.js";
 export const defaultPreflightGate = (vbriefPath) => {
@@ -525,7 +525,7 @@ export function swarmLaunch(args) {
     let modelSource = null;
     let routingProvider = null;
     if (routingFile !== null) {
-        routingProvider = dispatchProviderFromRuntime(runtimeMode);
+        routingProvider = resolveDispatchProvider(args.environ ?? process.env);
         const route = resolveModelRoute(routingFile, routingProvider, LEAF_CODING_WORKER_ROLE);
         // A malformed decision object must fail loud here: the legacy backend gate
         // was already bypassed above (routingFile !== null), so silently continuing

package/dist/swarm/routing-verify.d.ts

@@ -9,7 +9,7 @@ export interface VerifyRoutingOptions {
     advise?: boolean;
     /** Override the resolved provider (else derived from the runtime). */
     provider?: string | null;
-    /** Inject the runtime descriptor (else getPlatformCapabilities().runtimeMode). */
+    /** Inject the runtime descriptor (legacy test seam; else resolveDispatchProvider). */
     runtimeProbe?: () => string;
 }
 export interface VerifyRoutingResult {

package/dist/swarm/routing-verify.js

@@ -8,9 +8,8 @@
  *       1 = at least one in-scope role is undecided / not dispatchable
  *       2 = config error (unreadable / malformed route file)
  */
-import { getPlatformCapabilities } from "../intake/platform-capabilities.js";
 import { EXIT_CONFIG_ERROR, EXIT_GATE_FAILED, EXIT_OK } from "./constants.js";
-import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
+import { dispatchProviderFromRuntime, HARNESS_BOUND_PROVIDERS, loadRoutingFile, ROUTING_MODE_HARNESS_DEFAULT, resolveDispatchProvider, resolveModelRoute, resolveRoutingPath, } from "./routing.js";
 export const ROUTING_SET_CMD = "task swarm:routing-set -- --role <role> --model <slug>   (or --harness-default)";
 /** Roles the pre-dispatch gate checks by default: the actual model lever. */
 export const DEFAULT_GATED_ROLES = ["leaf-implementation"];
@@ -18,15 +17,17 @@ function resolveProvider(options) {
     if (options.provider !== undefined && options.provider !== null && options.provider.length > 0) {
         return options.provider;
     }
-    const probe = options.runtimeProbe ?? (() => getPlatformCapabilities().runtimeMode);
-    let runtimeMode = "";
-    try {
-        runtimeMode = probe();
-    }
-    catch {
-        runtimeMode = "";
+    if (options.runtimeProbe !== undefined) {
+        let runtimeMode = "";
+        try {
+            runtimeMode = options.runtimeProbe();
+        }
+        catch {
+            runtimeMode = "";
+        }
+        return dispatchProviderFromRuntime(runtimeMode);
     }
-    return dispatchProviderFromRuntime(runtimeMode);
+    return resolveDispatchProvider(options.environ ?? process.env);
 }
 export function verifyRouting(options) {
     const roles = options.roles && options.roles.length > 0 ? options.roles : DEFAULT_GATED_ROLES;

package/dist/swarm/routing.d.ts

@@ -9,6 +9,8 @@ export declare const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export declare const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export declare const HARNESS_BOUND_PROVIDERS: Set<string>;
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877). */
+export declare const ROUTING_GATED_DISPATCH_PROVIDERS: Set<string>;
 export interface RouteDecision {
     model: string | null;
     mode?: string;
@@ -48,6 +50,13 @@ export declare function loadRoutingFile(path: string): {
 export declare function resolveModelRoute(file: RoutingFile | null, provider: string, role: string): RouteResolution;
 /** Map a runtime descriptor (platform-capabilities.runtimeMode) to a route key. */
 export declare function dispatchProviderFromRuntime(runtimeMode: string): string;
+/**
+ * Resolve the `dispatch_provider` routing key from the active runtime envelope.
+ * Separate from `runtime_mode` (#1557): Cursor sessions may carry
+ * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
+ * `cursor` for model selection (#1877).
+ */
+export declare function resolveDispatchProvider(environ?: NodeJS.ProcessEnv): string;
 /**
  * Write a decision back to the route file (create-if-missing). Stamps
  * `decidedAt` when the caller did not supply one. Used by the interactive

package/dist/swarm/routing.js

@@ -31,6 +31,12 @@ export const ROUTING_MODE_HARNESS_DEFAULT = "harness-default";
 export const ROUTING_FILENAME = "routing.local.json";
 /** Providers whose model is harness-bound -- deft cannot pin or verify a slug. */
 export const HARNESS_BOUND_PROVIDERS = new Set(["grok"]);
+/** Providers whose per-role model must be decided before sub-agent dispatch (#1739 / #1877). */
+export const ROUTING_GATED_DISPATCH_PROVIDERS = new Set(["cursor", "grok"]);
+const TRUTHY_ENV = new Set(["1", "true", "yes", "on"]);
+function envTruthy(environ, name) {
+    return TRUTHY_ENV.has((environ[name] ?? "").trim().toLowerCase());
+}
 /**
  * Resolve the route-file path. Honors the `DEFT_ROUTING_PATH` override first
  * (keeps both maintainer and consumer testable), then reads from the MAIN
@@ -150,12 +156,52 @@ export function dispatchProviderFromRuntime(runtimeMode) {
     }
     return normalized;
 }
+/**
+ * Resolve the `dispatch_provider` routing key from the active runtime envelope.
+ * Separate from `runtime_mode` (#1557): Cursor sessions may carry
+ * `runtime_mode=cloud-headless` for gh-auth purposes but route under provider
+ * `cursor` for model selection (#1877).
+ */
+export function resolveDispatchProvider(environ = process.env) {
+    if (envTruthy(environ, "CURSOR_COMPOSER") || envTruthy(environ, "CURSOR_AGENT")) {
+        return "cursor";
+    }
+    const runtime = (environ.DEFT_AGENT_RUNTIME ?? "").trim().toLowerCase();
+    if (envTruthy(environ, "GROK_BUILD") || runtime === "grok-build") {
+        return "grok";
+    }
+    if (runtime === "cloud" || runtime === "headless") {
+        return "cloud-headless";
+    }
+    if (envTruthy(environ, "GITHUB_ACTIONS") ||
+        envTruthy(environ, "BUILDKITE") ||
+        (envTruthy(environ, "CI") &&
+            !envTruthy(environ, "CURSOR_COMPOSER") &&
+            !envTruthy(environ, "CURSOR_AGENT"))) {
+        return "cloud-headless";
+    }
+    return "unknown";
+}
+/**
+ * Keys that would mutate the prototype chain rather than set an own property
+ * if used as a computed object key. Rejected for provider/role names so a
+ * malicious routing input cannot pollute `Object.prototype` (CodeQL
+ * js/prototype-polluting-assignment).
+ */
+const FORBIDDEN_ROUTING_KEYS = new Set(["__proto__", "constructor", "prototype"]);
+function assertSafeRoutingKey(kind, key) {
+    if (FORBIDDEN_ROUTING_KEYS.has(key)) {
+        throw new Error(`routing ${kind} name "${key}" is not allowed`);
+    }
+}
 /**
  * Write a decision back to the route file (create-if-missing). Stamps
  * `decidedAt` when the caller did not supply one. Used by the interactive
  * resolver path (resolver step 5) and the `swarm:routing-set` task.
  */
 export function writeModelDecision(path, provider, role, decision) {
+    assertSafeRoutingKey("provider", provider);
+    assertSafeRoutingKey("role", role);
     const { data } = loadRoutingFile(path);
     const file = data ?? {};
     const existing = providerBlockOf(file, provider);

package/dist/swarm/verify-review-clean-cli.js

@@ -4,8 +4,11 @@ import { verifyReviewClean } from "./verify-review-clean.js";
 export function verifyReviewCleanMain(argv = process.argv.slice(2)) {
     const prNumbers = [];
     const cohortGlobs = [];
+    const ciIgnoreChecks = [];
     let repo = null;
     let emitJson = false;
+    let skipCi = false;
+    let skipSlizard = false;
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--cohort" && argv[i + 1] !== undefined) {
@@ -19,11 +22,32 @@ export function verifyReviewCleanMain(argv = process.argv.slice(2)) {
         else if (arg === "--json") {
             emitJson = true;
         }
+        else if (arg === "--skip-ci") {
+            skipCi = true;
+        }
+        else if (arg === "--skip-slizard") {
+            skipSlizard = true;
+        }
+        else if (arg === "--ci-ignore-check" && argv[i + 1] !== undefined) {
+            ciIgnoreChecks.push(argv[i + 1] ?? "");
+            i += 1;
+        }
+        else if (arg?.startsWith("--ci-ignore-check=")) {
+            ciIgnoreChecks.push(arg.slice("--ci-ignore-check=".length));
+        }
         else if (arg !== undefined && /^\d+$/.test(arg)) {
             prNumbers.push(Number.parseInt(arg, 10));
         }
     }
-    const result = verifyReviewClean({ prNumbers, cohortGlobs, repo, emitJson });
+    const result = verifyReviewClean({
+        prNumbers,
+        cohortGlobs,
+        repo,
+        emitJson,
+        skipCi,
+        skipSlizard,
+        ciIgnoreChecks,
+    });
     if (result.stdout.length > 0) {
         process.stdout.write(result.stdout);
     }

package/dist/swarm/verify-review-clean.d.ts

@@ -1,4 +1,7 @@
+import type { CiGateOptions } from "../pr-merge-readiness/ci-gate.js";
+import type { SlizardGateOptions } from "../pr-merge-readiness/slizard-gate.js";
 import type { RunGhFn } from "../pr-merge-readiness/types.js";
+type ReviewGateOptions = CiGateOptions & SlizardGateOptions;
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 export interface CohortResolutionError {
     vbrief_path: string;
@@ -10,6 +13,8 @@ export interface CohortPRResult {
     verdict: Record<string, unknown>;
     failures: string[];
     clean: boolean;
+    ci_summary: Record<string, unknown> | null;
+    slizard_summary: Record<string, unknown> | null;
 }
 export interface CohortResult {
     repo: string | null;
@@ -21,7 +26,7 @@ export declare function resolveCohortFromVbriefs(vbriefGlobs: readonly string[])
     prNumbers: number[];
     failures: CohortResolutionError[];
 };
-export declare function evaluatePr(prNumber: number, repo: string | null, runGh?: RunGhFn): CohortPRResult | null;
+export declare function evaluatePr(prNumber: number, repo: string | null, runGh?: RunGhFn, options?: ReviewGateOptions): CohortPRResult | null;
 export declare function cohortResultToDict(cohort: CohortResult): Record<string, unknown>;
 export declare function renderReviewCleanText(cohort: CohortResult): string;
 export interface VerifyReviewCleanArgs {
@@ -29,6 +34,9 @@ export interface VerifyReviewCleanArgs {
     cohortGlobs?: readonly string[];
     repo?: string | null;
     emitJson?: boolean;
+    skipCi?: boolean;
+    skipSlizard?: boolean;
+    ciIgnoreChecks?: readonly string[];
     runGh?: RunGhFn;
 }
 export declare function verifyReviewClean(args: VerifyReviewCleanArgs): {

package/dist/swarm/verify-review-clean.js

@@ -1,8 +1,10 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { hasArtifactSuffix } from "../layout/resolve.js";
-import { defaultRunGh, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
+import { buildCiSummaryLine, evaluateCiGate } from "../pr-merge-readiness/ci-gate.js";
+import { defaultRunGh, fetchCheckRunsRest, fetchGreptileCommentBody, fetchPrHeadSha, } from "../pr-merge-readiness/gh.js";
 import { evaluateGates, parseGreptileBody } from "../pr-merge-readiness/index.js";
+import { evaluateSlizardGate, isSlizardCheck } from "../pr-merge-readiness/slizard-gate.js";
 import { EXIT_EXTERNAL_ERROR, EXIT_OK, EXIT_UNCLEAN } from "./constants.js";
 function extractPrFromUri(uri) {
     const pullIdx = uri.indexOf("/pull/");
@@ -101,7 +103,7 @@ export function resolveCohortFromVbriefs(vbriefGlobs) {
     }
     return { prNumbers: seenPrs, failures };
 }
-export function evaluatePr(prNumber, repo, runGh = defaultRunGh) {
+export function evaluatePr(prNumber, repo, runGh = defaultRunGh, options = {}) {
     const headSha = fetchPrHeadSha(prNumber, repo, runGh);
     if (headSha === null) {
         return null;
@@ -112,12 +114,71 @@ export function evaluatePr(prNumber, repo, runGh = defaultRunGh) {
     }
     const verdict = parseGreptileBody(body);
     const failures = evaluateGates(prNumber, headSha, verdict);
+    let ciSummary = null;
+    let slizardSummary = null;
+    if (failures.length === 0) {
+        if (repo === null) {
+            failures.push("Could not resolve repo for required CI check-run gate. " +
+                "Use --repo OWNER/REPO or run from a checked-out repository.");
+            ciSummary = {
+                ready_state: "blocked",
+                error: "repo unresolved for check-runs lookup",
+            };
+            slizardSummary = { ready_state: "skipped", present: false };
+        }
+        else if (options.skipCi === true) {
+            const ci = evaluateCiGate([], { skipCi: true });
+            ciSummary = {
+                ...ci.summary,
+                summary_line: "CI check-runs: skipped (--skip-ci)",
+            };
+            const slizard = evaluateSlizardGate([], options);
+            failures.push(...slizard.failures);
+            slizardSummary = { ...slizard.summary };
+        }
+        else {
+            const checks = fetchCheckRunsRest(headSha, repo, runGh);
+            if (checks.summary === null) {
+                failures.push("Required CI check-runs could not be fetched; fail closed by default (#2169). " +
+                    `Root cause: ${checks.error}`);
+                ciSummary = {
+                    ready_state: "blocked",
+                    error: checks.error,
+                    checked_count: 0,
+                    ignored_checks: [...(options.ignoreCheckNames ?? [])],
+                    failed_required: [],
+                    pending_required: [],
+                    conclusions: [],
+                };
+                slizardSummary = { ready_state: "skipped", present: false };
+            }
+            else {
+                const slizard = evaluateSlizardGate(checks.checkRuns, options);
+                // SLizard is scored by the structured gate; exclude it from the generic CI set.
+                const slizardNames = checks.checkRuns
+                    .filter((r) => isSlizardCheck(r.name))
+                    .map((r) => r.name);
+                const ci = evaluateCiGate(checks.checkRuns, {
+                    skipCi: options.skipCi,
+                    ignoreCheckNames: [...(options.ignoreCheckNames ?? []), ...slizardNames],
+                });
+                failures.push(...ci.failures, ...slizard.failures);
+                ciSummary = {
+                    ...ci.summary,
+                    summary_line: buildCiSummaryLine(ci.summary),
+                };
+                slizardSummary = { ...slizard.summary };
+            }
+        }
+    }
     return {
         pr_number: prNumber,
         head_sha: headSha,
         verdict: { ...verdict },
         failures: [...failures],
         clean: failures.length === 0,
+        ci_summary: ciSummary,
+        slizard_summary: slizardSummary,
     };
 }
 export function cohortResultToDict(cohort) {
@@ -131,6 +192,8 @@ export function cohortResultToDict(cohort) {
             clean: r.clean,
             verdict: r.verdict,
             failures: r.failures,
+            ci_summary: r.ci_summary,
+            slizard_summary: r.slizard_summary,
         })),
         resolution_errors: cohort.resolution_errors,
     };
@@ -159,6 +222,12 @@ export function renderReviewCleanText(cohort) {
         lines.push(`    Findings:           P0=${String(v.p0Count ?? 0)}  ` +
             `P1=${String(v.p1Count ?? 0)}  P2=${String(v.p2Count ?? 0)}`);
         lines.push(`    Errored sentinel:   ${v.errored === true ? "True" : "False"}`);
+        if (r.ci_summary && typeof r.ci_summary.summary_line === "string") {
+            lines.push(`    ${r.ci_summary.summary_line}`);
+        }
+        if (r.slizard_summary && typeof r.slizard_summary.summary_line === "string") {
+            lines.push(`    ${r.slizard_summary.summary_line}`);
+        }
         r.failures.forEach((fail, index) => {
             lines.push(`      [${index + 1}] ${fail}`);
         });
@@ -212,7 +281,11 @@ export function verifyReviewClean(args) {
     const runGh = args.runGh ?? defaultRunGh;
     const prResults = [];
     for (const prNum of prNumbers) {
-        const perPr = evaluatePr(prNum, args.repo ?? null, runGh);
+        const perPr = evaluatePr(prNum, args.repo ?? null, runGh, {
+            skipCi: args.skipCi,
+            skipSlizard: args.skipSlizard,
+            ignoreCheckNames: args.ciIgnoreChecks,
+        });
         if (perPr === null) {
             return { exitCode: EXIT_EXTERNAL_ERROR, stdout: "", stderr: "" };
         }

package/dist/verify-source/biome-config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * biome-config.ts -- guard against #2190 (biome check . reports
+ * recommended-preset diagnostics as errors vs warnings non-deterministically
+ * on a pinned biome version).
+ *
+ * A preset-inherited rule severity can silently change tier across a biome
+ * version bump (or, per #2190, apparently even across runs on the identical
+ * pinned version). Pinning `noUnusedVariables` / `noNonNullAssertion` to an
+ * explicit non-"error" severity in biome.json makes the tier config-owned so
+ * it cannot flip a required CI check to failing on pre-existing diagnostics.
+ */
+/** The two rules #2190 observed flipping severity in CI (see docs/analysis/2026-07-02-2190-biome-determinism.md). */
+export declare const GUARDED_RULES: ReadonlyArray<{
+    readonly group: string;
+    readonly rule: string;
+}>;
+export interface RuleSeverityFinding {
+    readonly group: string;
+    readonly rule: string;
+    /** The literal severity value found, or null when the rule has no explicit entry. */
+    readonly severity: string | null;
+}
+export interface BiomeConfigGuardResult {
+    readonly code: 0 | 1 | 2;
+    readonly findings: readonly RuleSeverityFinding[];
+    readonly message: string;
+}
+/**
+ * Parse a biome.json document (already JSON.parse'd) and report the explicit
+ * severity declared for each guarded rule.
+ */
+export declare function findRuleSeverities(biomeConfig: unknown, rules?: ReadonlyArray<{
+    readonly group: string;
+    readonly rule: string;
+}>): RuleSeverityFinding[];
+/**
+ * Evaluate biome.json at `projectRoot` and fail closed when a guarded rule
+ * has no explicit severity, or an explicit severity of "error".
+ */
+export declare function evaluateBiomeConfigGuard(projectRoot?: string): BiomeConfigGuardResult;
+//# sourceMappingURL=biome-config.d.ts.map