@deftai/directive-core 0.81.0 → 0.83.0

package/dist/orphan-active/evaluate.js

@@ -0,0 +1,275 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { hasArtifactSuffix, resolveLifecycleRoot } from "../layout/resolve.js";
+import { defaultRunGh } from "../pr-protected-issues/gh.js";
+import { CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE } from "../triage/queue/constants.js";
+import { resolveRepo } from "../triage/queue/repo.js";
+import { collectGithubRefs } from "./refs.js";
+function readJson(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+function planOf(data) {
+    const plan = data?.plan;
+    return typeof plan === "object" && plan !== null && !Array.isArray(plan)
+        ? plan
+        : null;
+}
+function relBriefPath(path, projectRoot) {
+    try {
+        return relative(resolve(projectRoot), resolve(path)).replace(/\\/g, "/");
+    }
+    catch {
+        return path.replace(/\\/g, "/");
+    }
+}
+function listActiveRunningBriefs(projectRoot) {
+    let lifecycleRoot;
+    try {
+        lifecycleRoot = resolveLifecycleRoot(projectRoot);
+    }
+    catch {
+        return [];
+    }
+    const activeDir = join(lifecycleRoot, "active");
+    if (!existsSync(activeDir)) {
+        return [];
+    }
+    const out = [];
+    for (const entry of readdirSync(activeDir, { withFileTypes: true })) {
+        if (!entry.isFile() || !hasArtifactSuffix(entry.name)) {
+            continue;
+        }
+        const path = join(activeDir, entry.name);
+        const data = readJson(path);
+        const plan = planOf(data);
+        if (plan === null) {
+            continue;
+        }
+        if (String(plan.status ?? "").toLowerCase() !== "running") {
+            continue;
+        }
+        out.push({ path, plan });
+    }
+    return out.sort((a, b) => a.path.localeCompare(b.path));
+}
+function readCachedIssueState(projectRoot, ref) {
+    const [owner, name] = ref.repo.split("/", 2);
+    if (!owner || !name) {
+        return null;
+    }
+    const rawPath = join(projectRoot, CACHE_DIR_NAME, CACHE_SOURCE_GITHUB_ISSUE, owner, name, String(ref.number), "raw.json");
+    if (!existsSync(rawPath)) {
+        return null;
+    }
+    const raw = readJson(rawPath);
+    if (raw === null) {
+        return null;
+    }
+    const state = typeof raw.state === "string" ? raw.state.toLowerCase() : "";
+    if (state === "closed") {
+        return "closed";
+    }
+    if (state === "open") {
+        return "open";
+    }
+    return null;
+}
+function fetchIssueStateLive(ref, runGh) {
+    const path = `repos/${ref.repo}/issues/${ref.number}`;
+    const result = runGh(["gh", "api", path]);
+    if (result.returncode !== 0) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(result.stdout);
+        if (payload === null || typeof payload !== "object") {
+            return null;
+        }
+        const state = payload.state;
+        if (state === "closed") {
+            return "closed";
+        }
+        if (state === "open") {
+            return "open";
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function resolveIssueState(ref, projectRoot, runGh, skipGh) {
+    const cached = readCachedIssueState(projectRoot, ref);
+    if (cached !== null) {
+        return cached;
+    }
+    if (skipGh) {
+        return null;
+    }
+    return fetchIssueStateLive(ref, runGh);
+}
+function fetchPrMerged(ref, runGh) {
+    const path = `repos/${ref.repo}/pulls/${ref.number}`;
+    const result = runGh(["gh", "api", path]);
+    if (result.returncode !== 0) {
+        return null;
+    }
+    try {
+        const payload = JSON.parse(result.stdout);
+        if (payload === null || typeof payload !== "object") {
+            return null;
+        }
+        const mergedAt = payload.merged_at;
+        if (mergedAt === null) {
+            return false;
+        }
+        return typeof mergedAt === "string" && mergedAt.length > 0;
+    }
+    catch {
+        return null;
+    }
+}
+function assessOrphanSignature(issueRefs, prRefs, projectRoot, runGh, skipGh) {
+    for (const pr of prRefs) {
+        if (skipGh) {
+            continue;
+        }
+        const merged = fetchPrMerged(pr, runGh);
+        if (merged === true) {
+            return { orphaned: true, reason: `linked PR #${pr.number} is merged` };
+        }
+    }
+    if (issueRefs.length === 0) {
+        return { orphaned: false, reason: null };
+    }
+    let resolved = 0;
+    for (const ref of issueRefs) {
+        const state = resolveIssueState(ref, projectRoot, runGh, skipGh);
+        if (state === null) {
+            return { orphaned: false, reason: null };
+        }
+        resolved += 1;
+        if (state !== "closed") {
+            return { orphaned: false, reason: null };
+        }
+    }
+    if (resolved > 0) {
+        return { orphaned: true, reason: "all referenced issues are closed" };
+    }
+    return { orphaned: false, reason: null };
+}
+function formatRefusal(orphans, projectRoot) {
+    const lines = [
+        `verify:orphan-active: ${orphans.length} active/running xBRIEF${orphans.length === 1 ? "" : "s"} look shipped but still consume WIP (project_root=${projectRoot}).`,
+        "  Remediation: move each brief out of active/ with lifecycle ownership:",
+        "    task scope:complete -- xbrief/active/<file>.xbrief.json",
+        "    task scope:cancel -- xbrief/active/<file>.xbrief.json   # when abandoning",
+        "  For stop-at:pr-open workers the orchestrator owns post-merge complete/cancel;",
+        "  for drive-to:merge-ready workers scope:complete is part of the worker unit (#2321).",
+        "  Or run task swarm:finalize-cohort / task swarm:complete-cohort after cohort merge.",
+        "  Offending briefs:",
+    ];
+    for (const orphan of orphans) {
+        lines.push(`    - ${orphan.path} (${orphan.reason})`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Pure evaluator for orphaned active/running xBRIEF detection (#2321).
+ * Fails when active/ briefs with plan.status==running reference only closed
+ * issues and/or a merged PR — the stop-at:pr-open orphan signature.
+ */
+export function evaluate(projectRoot, options = {}) {
+    const root = resolve(projectRoot);
+    const quiet = options.quiet ?? false;
+    const skipGh = options.skipGh ?? false;
+    const runGh = options.runGh ?? defaultRunGh;
+    const defaultRepo = resolveRepo(options.repo, root);
+    if (!existsSync(root)) {
+        return {
+            code: 2,
+            message: `verify:orphan-active: project root does not exist: ${root}`,
+            stream: "stderr",
+            orphans: [],
+        };
+    }
+    let lifecycleRoot;
+    try {
+        lifecycleRoot = resolveLifecycleRoot(root);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        // Consumer/greenfield fixtures may still use legacy vbrief/ only (#2112).
+        // Orphan detection applies only to xbrief/active/ — skip cleanly, not config fail.
+        if (message.includes("No xbrief/ layout found")) {
+            if (quiet) {
+                return { code: 0, message: "", stream: "none", orphans: [] };
+            }
+            return {
+                code: 0,
+                message: "verify:orphan-active: no xbrief/ lifecycle root; nothing to scan.",
+                stream: "stdout",
+                orphans: [],
+            };
+        }
+        return {
+            code: 2,
+            message: `verify:orphan-active: ${message}`,
+            stream: "stderr",
+            orphans: [],
+        };
+    }
+    if (!existsSync(lifecycleRoot)) {
+        if (quiet) {
+            return { code: 0, message: "", stream: "none", orphans: [] };
+        }
+        return {
+            code: 0,
+            message: "verify:orphan-active: no xbrief/ lifecycle root; nothing to scan.",
+            stream: "stdout",
+            orphans: [],
+        };
+    }
+    const orphans = [];
+    for (const brief of listActiveRunningBriefs(root)) {
+        const { issues, prs } = collectGithubRefs(brief.plan, defaultRepo);
+        if (issues.length === 0 && prs.length === 0) {
+            continue;
+        }
+        const assessment = assessOrphanSignature(issues, prs, root, runGh, skipGh);
+        if (assessment.orphaned && assessment.reason !== null) {
+            orphans.push({
+                path: relBriefPath(brief.path, root),
+                reason: assessment.reason,
+            });
+        }
+    }
+    if (orphans.length > 0) {
+        return {
+            code: 1,
+            message: formatRefusal(orphans, root),
+            stream: "stderr",
+            orphans,
+        };
+    }
+    if (quiet) {
+        return { code: 0, message: "", stream: "none", orphans: [] };
+    }
+    const scanned = listActiveRunningBriefs(root).length;
+    return {
+        code: 0,
+        message: `verify:orphan-active: no orphaned active/running xBRIEFs ` +
+            `(scanned ${scanned} running brief${scanned === 1 ? "" : "s"} in active/).`,
+        stream: "stdout",
+        orphans: [],
+    };
+}
+//# sourceMappingURL=evaluate.js.map

package/dist/orphan-active/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./evaluate.js";
+export * from "./refs.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/orphan-active/index.js

@@ -0,0 +1,3 @@
+export * from "./evaluate.js";
+export * from "./refs.js";
+//# sourceMappingURL=index.js.map

package/dist/orphan-active/refs.d.ts

@@ -0,0 +1,16 @@
+export interface IssueRef {
+    readonly repo: string;
+    readonly number: number;
+}
+export interface PrRef {
+    readonly repo: string;
+    readonly number: number;
+}
+/** Parse (repo, pr_number) from a github-pr reference URI. */
+export declare function parseGithubPrUri(uri: unknown): [string | null, number | null];
+/** Collect GitHub issue and PR refs from a scope plan object. */
+export declare function collectGithubRefs(plan: Record<string, unknown>, defaultRepo: string | null): {
+    issues: IssueRef[];
+    prs: PrRef[];
+};
+//# sourceMappingURL=refs.d.ts.map

package/dist/orphan-active/refs.js

@@ -0,0 +1,105 @@
+import { referenceTypeMatches } from "@deftai/directive-types";
+import { parseGithubIssueUri } from "../triage/reconcile/parse-uri.js";
+/** Parse (repo, pr_number) from a github-pr reference URI. */
+export function parseGithubPrUri(uri) {
+    if (typeof uri !== "string") {
+        return [null, null];
+    }
+    const cleaned = uri.trim().replace(/\/$/, "");
+    if (!cleaned) {
+        return [null, null];
+    }
+    const noScheme = cleaned.includes("://") ? cleaned.split("://").slice(1).join("://") : cleaned;
+    const parts = noScheme.split("/").filter(Boolean);
+    if (parts.length >= 4 && parts[parts.length - 2] === "pull") {
+        const tail = parts[parts.length - 1] ?? "";
+        if (/^\d+$/.test(tail)) {
+            const owner = parts[parts.length - 4];
+            const repo = parts[parts.length - 3];
+            if (owner && repo) {
+                return [`${owner}/${repo}`, Number(tail)];
+            }
+        }
+    }
+    const tail = parts[parts.length - 1] ?? "";
+    if (/^\d+$/.test(tail)) {
+        return [null, Number(tail)];
+    }
+    return [null, null];
+}
+function parseTrackingIssue(value) {
+    if (typeof value === "number" && Number.isInteger(value) && value > 0) {
+        return value;
+    }
+    if (typeof value !== "string") {
+        return null;
+    }
+    const match = value.match(/#(\d+)/);
+    return match ? Number(match[1]) : null;
+}
+function addIssueRef(out, seen, repo, number, defaultRepo) {
+    if (number === null) {
+        return;
+    }
+    const resolvedRepo = repo ?? defaultRepo;
+    if (resolvedRepo === null || resolvedRepo.length === 0) {
+        return;
+    }
+    const key = `${resolvedRepo}:${number}`;
+    if (seen.has(key)) {
+        return;
+    }
+    seen.add(key);
+    out.push({ repo: resolvedRepo, number });
+}
+function addPrRef(out, seen, repo, number, defaultRepo) {
+    if (number === null) {
+        return;
+    }
+    const resolvedRepo = repo ?? defaultRepo;
+    if (resolvedRepo === null || resolvedRepo.length === 0) {
+        return;
+    }
+    const key = `${resolvedRepo}:${number}`;
+    if (seen.has(key)) {
+        return;
+    }
+    seen.add(key);
+    out.push({ repo: resolvedRepo, number });
+}
+/** Collect GitHub issue and PR refs from a scope plan object. */
+export function collectGithubRefs(plan, defaultRepo) {
+    const issues = [];
+    const prs = [];
+    const seenIssues = new Set();
+    const seenPrs = new Set();
+    const refs = plan.references;
+    if (Array.isArray(refs)) {
+        for (const ref of refs) {
+            if (typeof ref !== "object" || ref === null || Array.isArray(ref)) {
+                continue;
+            }
+            const typed = ref;
+            const type = String(typed.type ?? "");
+            if (referenceTypeMatches(type, "github-issue")) {
+                const [repo, number] = parseGithubIssueUri(typed.uri);
+                addIssueRef(issues, seenIssues, repo, number, defaultRepo);
+            }
+            else if (referenceTypeMatches(type, "github-pr")) {
+                const [repo, number] = parseGithubPrUri(typed.uri);
+                addPrRef(prs, seenPrs, repo, number, defaultRepo);
+            }
+        }
+    }
+    const metadata = plan.metadata;
+    if (typeof metadata === "object" && metadata !== null && !Array.isArray(metadata)) {
+        const tracking = metadata["x-tracking"];
+        if (typeof tracking === "object" && tracking !== null && !Array.isArray(tracking)) {
+            const t = tracking;
+            addIssueRef(issues, seenIssues, defaultRepo, parseTrackingIssue(t.parent_issue), defaultRepo);
+            addIssueRef(issues, seenIssues, defaultRepo, parseTrackingIssue(t.decomposition_origin), defaultRepo);
+        }
+    }
+    return { issues, prs };
+}
+//# sourceMappingURL=refs.js.map

package/dist/policy/host-hooks.d.ts

@@ -0,0 +1,21 @@
+import type { HookHost } from "../hooks/dispatcher.js";
+export declare const FIELD_HOST_HOOKS = "plan.policy.hostHooks";
+export declare const FIELD_HOST_HOOKS_CLI_ALIAS = "hostHooks";
+/** Per-host Directive hook deposit toggles (#2752). */
+export type HostHooksPolicy = Record<HookHost, boolean>;
+export declare const DEFAULT_HOST_HOOKS_POLICY: HostHooksPolicy;
+export interface HostHooksPolicyField {
+    readonly name: string;
+    readonly current: HostHooksPolicy;
+    readonly default: HostHooksPolicy;
+    readonly source: string;
+}
+/** Resolve typed host hook deposit policy from raw PROJECT-DEFINITION value. */
+export declare function resolveHostHooksPolicy(raw: unknown): HostHooksPolicy;
+export declare function validateHostHooks(value: unknown): string[];
+export declare function isHostHookDepositEnabled(host: HookHost, policy?: HostHooksPolicy): boolean;
+/** Inspector row for `policy:show --field=hostHooks`. */
+export declare function inspectHostHooks(data: Record<string, unknown> | null): HostHooksPolicyField;
+/** Resolve host hook deposit policy from PROJECT-DEFINITION on disk. */
+export declare function loadHostHooksPolicyFromProject(projectRoot: string): HostHooksPolicy;
+//# sourceMappingURL=host-hooks.d.ts.map

package/dist/policy/host-hooks.js

@@ -0,0 +1,96 @@
+import { HOOK_HOSTS } from "../hooks/dispatcher.js";
+import { readPlanPolicy } from "./plan-extensions.js";
+import { loadProjectDefinition } from "./resolve.js";
+export const FIELD_HOST_HOOKS = "plan.policy.hostHooks";
+export const FIELD_HOST_HOOKS_CLI_ALIAS = "hostHooks";
+export const DEFAULT_HOST_HOOKS_POLICY = {
+    claude: true,
+    cursor: true,
+    grok: true,
+    codex: true,
+};
+function readHostBoolean(rec, host, fallback) {
+    if (host in rec && typeof rec[host] === "boolean") {
+        return rec[host];
+    }
+    return fallback;
+}
+/** Resolve typed host hook deposit policy from raw PROJECT-DEFINITION value. */
+export function resolveHostHooksPolicy(raw) {
+    if (raw === null || raw === undefined) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    if (typeof raw !== "object" || Array.isArray(raw)) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    const rec = raw;
+    return {
+        claude: readHostBoolean(rec, "claude", DEFAULT_HOST_HOOKS_POLICY.claude),
+        cursor: readHostBoolean(rec, "cursor", DEFAULT_HOST_HOOKS_POLICY.cursor),
+        grok: readHostBoolean(rec, "grok", DEFAULT_HOST_HOOKS_POLICY.grok),
+        codex: readHostBoolean(rec, "codex", DEFAULT_HOST_HOOKS_POLICY.codex),
+    };
+}
+export function validateHostHooks(value) {
+    if (value === null || value === undefined) {
+        return [];
+    }
+    if (typeof value !== "object" || Array.isArray(value)) {
+        return [`${FIELD_HOST_HOOKS} must be an object; got ${typeof value}`];
+    }
+    const rec = value;
+    const errors = [];
+    for (const host of HOOK_HOSTS) {
+        if (host in rec && typeof rec[host] !== "boolean") {
+            errors.push(`${FIELD_HOST_HOOKS}.${host} must be a boolean`);
+        }
+    }
+    for (const key of Object.keys(rec)) {
+        if (!HOOK_HOSTS.includes(key)) {
+            errors.push(`${FIELD_HOST_HOOKS}.${key} is not a deposited host (${HOOK_HOSTS.join(", ")})`);
+        }
+    }
+    return errors;
+}
+export function isHostHookDepositEnabled(host, policy = DEFAULT_HOST_HOOKS_POLICY) {
+    return policy[host];
+}
+function fieldFromResolved(resolved, source) {
+    return {
+        name: FIELD_HOST_HOOKS,
+        current: resolved,
+        default: DEFAULT_HOST_HOOKS_POLICY,
+        source,
+    };
+}
+/** Inspector row for `policy:show --field=hostHooks`. */
+export function inspectHostHooks(data) {
+    if (data === null) {
+        return fieldFromResolved(DEFAULT_HOST_HOOKS_POLICY, "default");
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostHooks" in policyBlock)) {
+        return fieldFromResolved(DEFAULT_HOST_HOOKS_POLICY, "default");
+    }
+    const resolved = resolveHostHooksPolicy(policyBlock.hostHooks);
+    return fieldFromResolved(resolved, "typed");
+}
+/** Resolve host hook deposit policy from PROJECT-DEFINITION on disk. */
+export function loadHostHooksPolicyFromProject(projectRoot) {
+    const [data] = loadProjectDefinition(projectRoot);
+    if (data === null) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    const policyBlock = readPlanPolicy(data.plan);
+    if (typeof policyBlock !== "object" ||
+        policyBlock === null ||
+        Array.isArray(policyBlock) ||
+        !("hostHooks" in policyBlock)) {
+        return { ...DEFAULT_HOST_HOOKS_POLICY };
+    }
+    return resolveHostHooksPolicy(policyBlock.hostHooks);
+}
+//# sourceMappingURL=host-hooks.js.map

package/dist/policy/index.d.ts

@@ -3,6 +3,7 @@ export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
+export * from "./host-hooks.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";

package/dist/policy/index.js

@@ -1,3 +1,4 @@
+import { FIELD_HOST_HOOKS, FIELD_HOST_HOOKS_CLI_ALIAS, inspectHostHooks } from "./host-hooks.js";
 import { readPlanPolicy } from "./plan-extensions.js";
 import { FIELD_PRODUCT_SIGNAL, FIELD_PRODUCT_SIGNAL_CLI_ALIAS, inspectProductSignal, } from "./product-signal.js";
 import { coerceLegacyNarrative, LEGACY_NARRATIVE_KEY, loadProjectDefinition } from "./resolve.js";
@@ -10,6 +11,7 @@ export * from "./autonomy.js";
 export * from "./capacity.js";
 export * from "./decisions.js";
 export * from "./disclosure.js";
+export * from "./host-hooks.js";
 export * from "./plan-extensions.js";
 export * from "./policy-invocation.js";
 export * from "./product-signal.js";
@@ -258,6 +260,15 @@ function inspectRuntimeAuthorityField(data) {
         source: field.source,
     };
 }
+function inspectHostHooksField(data) {
+    const field = inspectHostHooks(data);
+    return {
+        name: field.name,
+        current: field.current,
+        default: field.default,
+        source: field.source,
+    };
+}
 const REGISTERED_POLICIES = [
     inspectAllowDirectCommits,
     inspectWipCap,
@@ -270,6 +281,7 @@ const REGISTERED_POLICIES = [
         emptyIsTyped: true,
     }),
     inspectSwarmSubagentBackend,
+    inspectHostHooksField,
     inspectStalenessTicklerField,
     inspectRuntimeAuthorityField,
     inspectProductSignalField,
@@ -290,7 +302,9 @@ export function inspectOnePolicy(name, projectRoot) {
                 ? FIELD_STALENESS_TICKLER
                 : name === FIELD_RUNTIME_AUTHORITY_CLI_ALIAS
                     ? FIELD_RUNTIME_AUTHORITY
-                    : name;
+                    : name === FIELD_HOST_HOOKS_CLI_ALIAS
+                        ? FIELD_HOST_HOOKS
+                        : name;
     for (const field of inspectAllPolicies(projectRoot)) {
         if (field.name === normalized)
             return field;

package/dist/pr-wait-mergeable/cascade.d.ts

@@ -1,8 +1,16 @@
+import { type SemanticGreenFn } from "./semantic-green.js";
 import type { MergeFn, MonitorFn, ProtectedCheckFn, WaitMergeableResult } from "./types.js";
 export interface WaitMergeableOptions {
     readonly protectedFn?: ProtectedCheckFn;
     readonly monitorFn?: MonitorFn;
     readonly mergeFn?: MergeFn;
+    readonly semanticGreenFn?: SemanticGreenFn;
+    /** Enable merge-cascade semantic-green gate (#2385). */
+    readonly cascadeMode?: boolean;
+    /** After a prior cascade merge, require target-branch CI green at HEAD. */
+    readonly requireMasterCiGreen?: boolean;
+    /** Target branch override for stale-base comparison (defaults to PR base.ref). */
+    readonly baseBranch?: string | null;
 }
 /** Run protected-check -> wait -> merge cascade (#1369). */
 export declare function waitMergeableAndMerge(prNumber: number, repo: string, options: {

package/dist/pr-wait-mergeable/cascade.js

@@ -1,6 +1,7 @@
 import { classifyMonitorOutcome, parseMonitorPayload } from "./classify.js";
 import { EXIT_CONFIG_ERROR, EXIT_MERGED, EXIT_TIMEOUT_OR_ESCALATION } from "./constants.js";
 import { makeResult } from "./result.js";
+import { evaluateSemanticGreen } from "./semantic-green.js";
 import { runGhMerge, runMonitor, runProtectedCheck } from "./wrappers.js";
 /** Node module-not-found / missing script — not a protected-issue overlap (#2667). */
 function isProtectedCheckConfigFailure(stderr) {
@@ -14,6 +15,7 @@ export function waitMergeableAndMerge(prNumber, repo, options) {
     const protectedFn = options.protectedFn ?? runProtectedCheck;
     const monitorFn = options.monitorFn ?? runMonitor;
     const mergeFn = options.mergeFn ?? runGhMerge;
+    const semanticGreenFn = options.semanticGreenFn ?? evaluateSemanticGreen;
     const protectedIssues = options.protected;
     let protectedCheckPayload = {};
     if (protectedIssues.length > 0) {
@@ -47,6 +49,22 @@ export function waitMergeableAndMerge(prNumber, repo, options) {
             });
         }
     }
+    const semanticGreen = semanticGreenFn(prNumber, repo, {
+        cascadeMode: options.cascadeMode,
+        requireMasterCiGreen: options.requireMasterCiGreen,
+        baseBranch: options.baseBranch,
+    });
+    if (!semanticGreen.ok) {
+        return makeResult({
+            prNumber,
+            repo,
+            outcome: semanticGreen.outcome ?? "semantic-green-blocked",
+            exitCode: semanticGreen.exitCode ?? EXIT_TIMEOUT_OR_ESCALATION,
+            protectedCheck: protectedCheckPayload,
+            semanticGreen: { ...semanticGreen.payload },
+            error: semanticGreen.error,
+        });
+    }
     const [monRc, monStdout, monStderr] = monitorFn(prNumber, repo, options.capMinutes);
     const monitorPayload = parseMonitorPayload(monStdout);
     const [outcome, monitorExit] = classifyMonitorOutcome(monRc, monitorPayload);

package/dist/pr-wait-mergeable/main.d.ts

@@ -5,6 +5,9 @@ export interface ParsedWaitMergeableArgs {
     readonly capMinutes: number;
     readonly protectedValues: readonly string[];
     readonly emitJson: boolean;
+    readonly cascadeMode: boolean;
+    readonly requireMasterCiGreen: boolean;
+    readonly baseBranch: string | null;
     readonly error?: string;
 }
 export declare function parseWaitMergeableArgs(argv: readonly string[]): ParsedWaitMergeableArgs;
@@ -12,6 +15,7 @@ export interface RunWaitMergeableOptions {
     readonly protectedFn?: Parameters<typeof waitMergeableAndMerge>[2]["protectedFn"];
     readonly monitorFn?: Parameters<typeof waitMergeableAndMerge>[2]["monitorFn"];
     readonly mergeFn?: Parameters<typeof waitMergeableAndMerge>[2]["mergeFn"];
+    readonly semanticGreenFn?: Parameters<typeof waitMergeableAndMerge>[2]["semanticGreenFn"];
 }
 export declare function runWaitMergeable(argv: readonly string[], options?: RunWaitMergeableOptions): number;
 export declare function cmdPrWaitMergeable(argv: readonly string[], options?: RunWaitMergeableOptions): number;