@deftai/directive-core 0.66.1 → 0.67.0

package/dist/pr-merge-readiness/slizard-gate.js

@@ -0,0 +1,119 @@
+/**
+ * Dedicated gate for the SLizard second-reviewer verdict (#2189).
+ *
+ * SLizard posts a check-run whose `output.summary` carries a structured verdict:
+ *
+ *   Decision: request_changes
+ *   Merge impact: blocking
+ *   Findings: 2 (P0: 0, P1: 1, P2: 0, P3: 0)
+ *
+ * The generic CI check-run gate (#2169) only fails closed on a check-run
+ * `conclusion` in the failed set, so a blocking *decision* carried on a
+ * non-`failure` conclusion (e.g. `neutral`) would slip through and the review
+ * is surfaced indistinctly among build/test checks. This gate parses the
+ * structured verdict and fails merge-readiness on a blocking decision.
+ */
+/** Canonical SLizard check-run name; matching is case-insensitive substring for resilience. */
+export const SLIZARD_CHECK_NAME = "SLizard";
+const FAILED_CONCLUSIONS = new Set(["failure", "cancelled", "timed_out"]);
+const PENDING_STATUSES = new Set(["queued", "in_progress"]);
+const BLOCKING_DECISIONS = new Set(["request_changes", "changes_requested", "reject"]);
+export function isSlizardCheck(name) {
+    return name.toLowerCase().includes("slizard");
+}
+function firstMatch(text, re) {
+    const m = re.exec(text);
+    return m?.[1] !== undefined ? m[1].trim() : null;
+}
+function countFor(text, sev) {
+    const m = new RegExp(`${sev}\\s*:\\s*(\\d+)`, "i").exec(text);
+    return m?.[1] !== undefined ? Number.parseInt(m[1], 10) : null;
+}
+/** Parse a SLizard check-run `output.summary` into a structured verdict. */
+export function parseSlizardVerdict(summary) {
+    const text = summary ?? "";
+    const decision = firstMatch(text, /Decision\s*:\s*([A-Za-z_]+)/i);
+    const mergeImpact = firstMatch(text, /Merge impact\s*:\s*([A-Za-z_-]+)/i);
+    return {
+        decision: decision ? decision.toLowerCase() : null,
+        mergeImpact: mergeImpact ? mergeImpact.toLowerCase() : null,
+        p0Count: countFor(text, "P0"),
+        p1Count: countFor(text, "P1"),
+        p2Count: countFor(text, "P2"),
+    };
+}
+function skippedSummary(reason) {
+    return {
+        ready_state: "skipped",
+        present: false,
+        check_name: null,
+        status: null,
+        conclusion: null,
+        verdict: null,
+        summary_line: `SLizard review: skipped (${reason})`,
+    };
+}
+function isPending(status, conclusion) {
+    if (PENDING_STATUSES.has(status)) {
+        return true;
+    }
+    return status !== "completed" || conclusion === "none";
+}
+export function evaluateSlizardGate(checkRuns, options = {}) {
+    if (options.skipSlizard === true) {
+        return { failures: [], summary: skippedSummary("--skip-slizard") };
+    }
+    const run = checkRuns.find((r) => isSlizardCheck(r.name));
+    if (run === undefined) {
+        // SLizard is an optional second reviewer; its absence does not block merge.
+        return { failures: [], summary: skippedSummary("no SLizard check-run on this commit") };
+    }
+    const verdict = parseSlizardVerdict(run.summary);
+    const blockingDecision = verdict.decision !== null && BLOCKING_DECISIONS.has(verdict.decision);
+    const blockingImpact = verdict.mergeImpact === "blocking";
+    const failedConclusion = FAILED_CONCLUSIONS.has(run.conclusion);
+    const failures = [];
+    let readyState;
+    if (blockingDecision || blockingImpact || failedConclusion) {
+        readyState = "blocked";
+        const reasons = [];
+        if (verdict.decision !== null) {
+            reasons.push(`decision=${verdict.decision}`);
+        }
+        if (verdict.mergeImpact !== null) {
+            reasons.push(`merge impact=${verdict.mergeImpact}`);
+        }
+        if (failedConclusion) {
+            reasons.push(`conclusion=${run.conclusion}`);
+        }
+        const findings = verdict.p0Count !== null || verdict.p1Count !== null || verdict.p2Count !== null
+            ? ` (P0=${verdict.p0Count ?? 0} P1=${verdict.p1Count ?? 0} P2=${verdict.p2Count ?? 0})`
+            : "";
+        failures.push(`SLizard review is blocking: ${reasons.join(", ")}${findings}. ` +
+            "Resolve the SLizard findings or pass --skip-slizard to override (#2189).");
+    }
+    else if (isPending(run.status, run.conclusion)) {
+        readyState = "not_ready_yet";
+        failures.push(`SLizard review still in progress (${run.status}); wait for the verdict before merge (#2189).`);
+    }
+    else {
+        readyState = "ready";
+    }
+    const parts = [
+        `decision=${verdict.decision ?? "?"}`,
+        `impact=${verdict.mergeImpact ?? "?"}`,
+    ];
+    return {
+        failures,
+        summary: {
+            ready_state: readyState,
+            present: true,
+            check_name: run.name,
+            status: run.status,
+            conclusion: run.conclusion,
+            verdict,
+            summary_line: `SLizard review: ${readyState} (${parts.join(", ")})`,
+        },
+    };
+}
+//# sourceMappingURL=slizard-gate.js.map

package/dist/preflight-cache/evaluate.d.ts

@@ -34,6 +34,7 @@ export interface EvaluateOptions {
     /** Injectable drift probe for tests. */
     probeDriftFn?: (repo: string, cacheRoot: string, source: string) => CacheDriftProbeResult | null;
 }
+export declare function normaliseRepoUrl(url: string): string | null;
 /**
  * Branch-aware recovery hint (#1953 Option 3).
  * Age-stale (or age+drift mixed) → --force bypasses TTL; drift-only → plain refetch.

package/dist/preflight-cache/evaluate.js

@@ -44,19 +44,26 @@ function inferRepoFromGit(projectRoot) {
         return null;
     }
 }
-function normaliseRepoUrl(url) {
+export function normaliseRepoUrl(url) {
     if (!url)
         return null;
-    const cleaned = url.replace(/\/$/, "").replace(/\.git$/, "");
-    if (!cleaned.includes("github.com"))
+    const cleaned = url
+        .trim()
+        .replace(/\/$/, "")
+        .replace(/\.git$/, "");
+    // Match `github.com` only as the HOST component of the remote URL: right
+    // after an optional scheme and optional `user@`, and immediately followed by
+    // `:` or `/`. A plain `includes("github.com")` would also accept spoofed
+    // hosts like `github.com.evil.com` or `evil.com/github.com/...` (CodeQL
+    // js/incomplete-url-substring-sanitization). Supports https/ssh/git schemes
+    // and the scp-like `git@github.com:owner/repo` form.
+    const match = cleaned.match(/^(?:(?:https?|ssh|git):\/\/)?(?:[^/@]+@)?github\.com[:/]+([^/]+)\/([^/]+)/i);
+    if (!match)
         return null;
-    const tail = cleaned
-        .split("github.com")
-        .pop()
-        ?.replace(/^[:/]+/, "") ?? "";
-    const parts = tail.split("/");
-    if (parts.length >= 2 && parts[0] && parts[1]) {
-        return `${parts[0]}/${parts[1]}`;
+    const owner = match[1];
+    const repo = match[2];
+    if (owner && repo) {
+        return `${owner}/${repo}`;
     }
     return null;
 }

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): {