@deftai/directive-core 0.81.0 → 0.82.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/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;

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

@@ -16,22 +16,45 @@ export function parseWaitMergeableArgs(argv) {
     let capMinutes = 60;
     const protectedValues = [];
     let emitJson = false;
+    let cascadeMode = false;
+    let requireMasterCiGreen = false;
+    let baseBranch = null;
+    const baseReturn = () => ({
+        prNumber,
+        repo,
+        capMinutes,
+        protectedValues,
+        emitJson,
+        cascadeMode,
+        requireMasterCiGreen,
+        baseBranch,
+    });
     for (let i = 0; i < argv.length; i += 1) {
         const arg = argv[i];
         if (arg === "--json") {
             emitJson = true;
         }
+        else if (arg === "--cascade") {
+            cascadeMode = true;
+        }
+        else if (arg === "--require-master-ci-green") {
+            requireMasterCiGreen = true;
+        }
+        else if (arg === "--base-branch") {
+            const value = argv[i + 1];
+            if (value === undefined) {
+                return { ...baseReturn(), error: "argument --base-branch: expected one argument" };
+            }
+            baseBranch = value;
+            i += 1;
+        }
+        else if (arg?.startsWith("--base-branch=")) {
+            baseBranch = arg.slice("--base-branch=".length);
+        }
         else if (arg === "--repo") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --repo: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --repo: expected one argument" };
             }
             repo = value;
             i += 1;
@@ -42,25 +65,11 @@ export function parseWaitMergeableArgs(argv) {
         else if (arg === "--cap-minutes") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --cap-minutes: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --cap-minutes: expected one argument" };
             }
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid --cap-minutes value: ${value}`,
-                };
+                return { ...baseReturn(), error: `invalid --cap-minutes value: ${value}` };
             }
             capMinutes = parsed;
             i += 1;
@@ -69,28 +78,14 @@ export function parseWaitMergeableArgs(argv) {
             const value = arg.slice("--cap-minutes=".length);
             const parsed = Number(value);
             if (!Number.isFinite(parsed)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid --cap-minutes value: ${value}`,
-                };
+                return { ...baseReturn(), error: `invalid --cap-minutes value: ${value}` };
             }
             capMinutes = parsed;
         }
         else if (arg === "--protected") {
             const value = argv[i + 1];
             if (value === undefined) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: "argument --protected: expected one argument",
-                };
+                return { ...baseReturn(), error: "argument --protected: expected one argument" };
             }
             protectedValues.push(value);
             i += 1;
@@ -99,51 +94,23 @@ export function parseWaitMergeableArgs(argv) {
             protectedValues.push(arg.slice("--protected=".length));
         }
         else if (arg?.startsWith("-")) {
-            return {
-                prNumber,
-                repo,
-                capMinutes,
-                protectedValues,
-                emitJson,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return { ...baseReturn(), error: `unrecognized arguments: ${arg}` };
         }
         else if (prNumber === null) {
             const n = Number(arg);
             if (!Number.isInteger(n)) {
-                return {
-                    prNumber,
-                    repo,
-                    capMinutes,
-                    protectedValues,
-                    emitJson,
-                    error: `invalid PR number: ${arg}`,
-                };
+                return { ...baseReturn(), error: `invalid PR number: ${arg}` };
             }
             prNumber = n;
         }
         else {
-            return {
-                prNumber,
-                repo,
-                capMinutes,
-                protectedValues,
-                emitJson,
-                error: `unrecognized arguments: ${arg}`,
-            };
+            return { ...baseReturn(), error: `unrecognized arguments: ${arg}` };
         }
     }
     if (prNumber === null) {
-        return {
-            prNumber,
-            repo,
-            capMinutes,
-            protectedValues,
-            emitJson,
-            error: "the following arguments are required: pr_number",
-        };
+        return { ...baseReturn(), error: "the following arguments are required: pr_number" };
     }
-    return { prNumber, repo, capMinutes, protectedValues, emitJson };
+    return baseReturn();
 }
 function summaryLabelForExit(exitCode) {
     switch (exitCode) {
@@ -183,6 +150,10 @@ export function runWaitMergeable(argv, options = {}) {
         protectedFn: options.protectedFn,
         monitorFn: options.monitorFn,
         mergeFn: options.mergeFn,
+        semanticGreenFn: options.semanticGreenFn,
+        cascadeMode: args.cascadeMode,
+        requireMasterCiGreen: args.requireMasterCiGreen,
+        baseBranch: args.baseBranch,
     });
     const summaryLabel = summaryLabelForExit(result.exitCode);
     process.stderr.write(`[pr_wait_mergeable] PR #${result.prNumber} repo=${result.repo} ` +

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

@@ -1,8 +1,9 @@
 import type { WaitMergeableResult } from "./types.js";
 export declare function toResultDict(result: WaitMergeableResult): Record<string, unknown>;
-export declare function makeResult(fields: Omit<WaitMergeableResult, "monitorResult" | "protectedCheck" | "mergeStdout" | "mergeStderr"> & {
+export declare function makeResult(fields: Omit<WaitMergeableResult, "monitorResult" | "protectedCheck" | "semanticGreen" | "mergeStdout" | "mergeStderr"> & {
     readonly monitorResult?: Record<string, unknown>;
     readonly protectedCheck?: Record<string, unknown>;
+    readonly semanticGreen?: Record<string, unknown>;
     readonly mergeStdout?: string;
     readonly mergeStderr?: string;
 }): WaitMergeableResult;