opencode-magi 0.11.0 → 0.12.0

package/dist/config/validate.js

@@ -20,12 +20,12 @@ function requiredErrors(config, { creator = false, editor = false, github = true
         required(github, config.github.owner, "github.owner"),
         required(github, config.github.repo, "github.repo"),
         required(reviewers, config.review.reviewers, "review.reviewers"),
-        ...(config.review.reviewers ?? []).map((reviewer, index) => required(reviewers || !!reviewer, reviewer.model, `review.reviewers[${index}].model`)),
+        ...(config.review.reviewers ?? []).map((reviewer, index) => required(reviewers, reviewer.model, `review.reviewers[${index}].model`)),
         required(editor, config.merge.editor, "merge.editor"),
         required(editor, config.merge.editor?.model, "merge.editor.model"),
         required(editor, config.merge.editor?.author, "merge.editor.author"),
         required(voters, config.triage.voters, "triage.voters"),
-        ...(config.triage.voters ?? []).map((voter, index) => required(voters || !!voter, voter.model, `triage.voters[${index}].model`)),
+        ...(config.triage.voters ?? []).map((voter, index) => required(voters, voter.model, `triage.voters[${index}].model`)),
         required(creator, config.triage.creator, "triage.creator"),
         required(creator, config.triage.creator?.model, "triage.creator.model"),
         required(creator, config.triage.creator?.author, "triage.creator.author"),
@@ -88,23 +88,18 @@ async function authErrors(config, exec) {
         return filterEmpty([await authError(config, exec, config.account)]);
     }
     else {
-        const accounts = {
-            ...Object.fromEntries(config.review.reviewers?.map(({ account }, index) => [
-                account,
-                `review.reviewers[${index}]`,
-            ]) ?? []),
-            ...Object.fromEntries(config.triage.voters?.map(({ account }, index) => [
-                account,
-                `triage.voters[${index}]`,
-            ]) ?? []),
-        };
-        if (config.merge.editor)
-            accounts[config.merge.editor.account] = "merge.editor";
-        if (config.triage.creator)
-            accounts[config.triage.creator.account] = "triage.creator";
+        const reviewerAccounts = config.review.reviewers?.map(({ account }) => account) ?? [];
+        const voterAccounts = config.triage.voters?.map(({ account }) => account) ?? [];
+        const accounts = new Set(filterEmpty([
+            ...reviewerAccounts,
+            ...voterAccounts,
+            config.merge.editor?.account,
+            config.triage.creator?.account,
+        ]));
         return filterEmpty([
-            ...duplicateErrors(Object.keys(accounts), (value) => `${accounts[value]} has duplicate account: ${value}`),
-            ...(await Promise.all(Object.keys(accounts).map((account) => authError(config, exec, account)))),
+            ...duplicateErrors(reviewerAccounts, (value) => `review.reviewers has duplicate account: ${value}`),
+            ...duplicateErrors(voterAccounts, (value) => `triage.voters has duplicate account: ${value}`),
+            ...(await Promise.all([...accounts].map((account) => authError(config, exec, account)))),
         ]);
     }
 }

package/dist/constant.js

@@ -60,11 +60,7 @@ export const DEFAULT_CONFIG = {
             queue: false,
         },
         output: ".magi/runs/pr",
-        safety: {
-            allowAuthors: [],
-            blockedPaths: [],
-            requiredLabels: [],
-        },
+        safety: [],
         worktree: ".magi/worktrees/pr",
     },
     triage: {

package/dist/tools/merge/context.js

@@ -95,9 +95,7 @@ function createSyntheticThreads() {
     }));
 }
 function addSyntheticReplies(threads) {
-    const output = this.state.editor?.outputs?.at(-1);
-    if (!output)
-        throw new MagiError("blocked", "Editor output not found.");
+    const output = this.state.editor.outputs.at(-1);
     return threads.map((thread) => ({
         ...thread,
         comments: [

package/dist/tools/merge/editor.js

@@ -183,12 +183,6 @@ async function setAccount() {
     await this.exec(command("git", "config", "user.email", quote(this.state.editor.author.email)), options);
 }
 async function push() {
-    if (!this.state.editor?.account)
-        throw new MagiError("blocked", "Editor account not found.");
-    if (!this.state.pr?.metadata)
-        throw new MagiError("blocked", "PR metadata not found.");
-    if (!this.state.worktree)
-        throw new MagiError("blocked", "PR worktree not found.");
     const token = await this.magi.getGhToken(this.state.editor.account, this.context.abort);
     const url = `https://${this.config.github.host}/${this.state.pr.metadata.head.repo.owner.login}/${this.state.pr.metadata.head.repo.name}.git`;
     const ref = `HEAD:refs/heads/${this.state.pr.metadata.head.ref}`;
@@ -208,8 +202,6 @@ async function push() {
     return getMetadata.call(this);
 }
 async function getConflictedFiles() {
-    if (!this.state.worktree)
-        throw new MagiError("blocked", "PR worktree not found.");
     const options = { cwd: this.state.worktree.path, signal: this.context.abort };
     try {
         await this.exec(command("git", "merge", "--no-commit", "--no-ff", "FETCH_HEAD"), options);

package/dist/tools/merge/index.js

@@ -127,7 +127,7 @@ export const merge = function (magi) {
                                 await run.editCycles(async () => editCycle(run));
                             const automation = await run.automate();
                             if (automation === "CONFLICT" &&
-                                run.config.merge.automation.conflict) {
+                                run.isAutomationEnabled(run.config.merge.automation.conflict)) {
                                 await run.editCycles(async (cycle) => editCycle(run, { conflict: true, cycle }));
                                 await run.automate();
                             }

package/dist/tools/review/action.js

@@ -1,6 +1,7 @@
 import { MagiError } from "@/magi";
 import { Prompt } from "@/prompts";
-import { command, filterEmpty, isArray, isObject, isString, loop, marker, omitNullish, quote, retry, wait, Worker, } from "@/utils";
+import { command, filterEmpty, ignoreError, isArray, isBoolean, isObject, isString, loop, marker, omitNullish, quote, retry, wait, Worker, } from "@/utils";
+import { getConditionErrors } from "./check";
 const events = {
     APPROVED: "APPROVE",
     CHANGES_REQUESTED: "REQUEST_CHANGES",
@@ -181,9 +182,8 @@ export async function automate() {
         throw new MagiError("blocked", "PR verdict not found.");
     if (!["APPROVED", "CLOSED"].includes(this.state.pr.verdict))
         return "SKIPPED";
-    const automation = this.config[this.state.command].automation;
     const action = this.state.pr.verdict === "APPROVED" ? "merge" : "close";
-    if (!automation[action]) {
+    if (!isAutomationEnabled.call(this, this.config[this.state.command].automation[action])) {
         await this.updateState({ pr: { automation: "SKIPPED" } });
         await this.updateEvent(`Skipped ${action} automation.`);
         return "SKIPPED";
@@ -233,7 +233,24 @@ export async function automate() {
         const octokit = await this.magi.createOctokit(this.config, this.context.abort, account);
         const graphql = this.magi.createGraphql(octokit);
         const enqueuedAt = new Date().toISOString();
-        await graphql.enqueuePullRequest({ id: this.state.pr.metadata.node_id });
+        try {
+            await ignoreError(() => graphql.enqueuePullRequest({ id: this.state.pr.metadata.node_id }), (e) => {
+                const message = e instanceof Error ? e.message : String(e);
+                return /pull request is already in the queue/i.test(message);
+            });
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            if (!/pull request is closed/i.test(message))
+                throw e;
+            const { repository } = await graphql.mergeQueueStatus({
+                owner: this.config.github.owner,
+                pr: this.number,
+                repo: this.config.github.repo,
+            });
+            if (repository?.pullRequest?.state !== "MERGED")
+                throw e;
+        }
         await this.updateEvent(`Waiting for merge queue.`);
         const result = await waitMergeQueue.call(this, enqueuedAt);
         if (result === "CONFLICT")
@@ -328,6 +345,18 @@ export async function automate() {
     await this.updateEvent(`Finished ${action} automation.`);
     return action === "merge" ? "MERGED" : "CLOSED";
 }
+export function isAutomationEnabled(conditions) {
+    if (isBoolean(conditions))
+        return conditions;
+    const edited = !this.state.dryRun &&
+        this.state.editor?.outputs?.some(({ commitSha }) => !!commitSha);
+    return conditions.every(([expected, condition]) => {
+        const errors = getConditionErrors(condition, this.state.pr.metadata, this.state.pr.files ?? []);
+        const matches = !errors.length &&
+            (!("edited" in condition) || condition.edited === !!edited);
+        return matches === expected;
+    });
+}
 function hasFailedChecks(checks) {
     if (!isArray(checks))
         return false;
@@ -388,8 +417,11 @@ async function waitMergeQueue(enqueuedAt, leftMergeQueue = false, retries = 0) {
             const attempt = retries + 1;
             const nextEnqueuedAt = new Date().toISOString();
             await this.updateEvent(`Attempt ${attempt} failed to merge from the merge queue. Retrying...`);
-            await this.graphql.enqueuePullRequest({
+            await ignoreError(() => this.graphql.enqueuePullRequest({
                 id: this.state.pr.metadata.node_id,
+            }), (e) => {
+                const message = e instanceof Error ? e.message : String(e);
+                return /pull request is already in the queue/i.test(message);
             });
             return await waitMergeQueue.call(this, nextEnqueuedAt, false, attempt);
         }
@@ -401,8 +433,6 @@ async function waitMergeQueue(enqueuedAt, leftMergeQueue = false, retries = 0) {
 async function isConflict() {
     if (!this.state.worktree)
         return false;
-    if (!this.state.pr?.metadata)
-        throw new MagiError("blocked", "PR metadata not found.");
     const options = { cwd: this.state.worktree.path, signal: this.context.abort };
     const status = await this.exec(command("git", "status", "--porcelain"), options);
     if (status)

package/dist/tools/review/check.js

@@ -1,7 +1,7 @@
 import picomatch from "picomatch";
 import { MagiError } from "@/magi";
 import { Prompt } from "@/prompts";
-import { command, filterEmpty, isNumber, omitNullish, quote, retry, Worker, } from "@/utils";
+import { command, filterEmpty, isBoolean, isNumber, omitNullish, quote, retry, Worker, } from "@/utils";
 const ci = {
     isExcluded(exclude, { name }) {
         return exclude.some((pattern) => {
@@ -22,6 +22,65 @@ const ci = {
         return !this.isFailed(check) && !this.isPassed(check);
     },
 };
+function matchesValues(filter, values) {
+    if (!filter)
+        return true;
+    if ("include" in filter &&
+        !values.some((value) => filter.include.includes(value)))
+        return false;
+    return !("exclude" in filter &&
+        values.some((value) => filter.exclude.includes(value)));
+}
+function matchesPatterns(filter, values) {
+    if (!filter)
+        return true;
+    if ("include" in filter) {
+        const isIncluded = picomatch(filter.include, { dot: true });
+        if (!values.some((value) => isIncluded(value)))
+            return false;
+    }
+    if ("exclude" in filter) {
+        const isExcluded = picomatch(filter.exclude, { dot: true });
+        if (values.some((value) => isExcluded(value)))
+            return false;
+    }
+    return true;
+}
+export function getConditionErrors(condition, metadata, files) {
+    const errors = [];
+    const branches = condition.branches
+        ? {
+            base: "base" in condition.branches ? condition.branches.base : undefined,
+            head: "head" in condition.branches ? condition.branches.head : undefined,
+        }
+        : {};
+    if (!matchesValues(condition.authors, [metadata.user.login]))
+        errors.push(`Author does not match safety filter: ${metadata.user.login}.`);
+    if (!matchesPatterns(branches.base, [metadata.base.ref]))
+        errors.push(`Base branch does not match safety filter: ${metadata.base.ref}.`);
+    if (!matchesPatterns(branches.head, [metadata.head.ref]))
+        errors.push(`Head branch does not match safety filter: ${metadata.head.ref}.`);
+    if (!matchesValues(condition.labels, metadata.labels.map(({ name }) => name)))
+        errors.push(`Labels do not match safety filter.`);
+    if (!matchesPatterns(condition.paths, files))
+        errors.push(`Paths do not match safety filter.`);
+    if (isNumber(condition.maxChangedFiles) &&
+        metadata.changed_files > condition.maxChangedFiles)
+        errors.push(`Changed files exceed limit: ${metadata.changed_files} > ${condition.maxChangedFiles}.`);
+    return errors;
+}
+function getSafetyErrors(conditions, metadata, files) {
+    if (isBoolean(conditions))
+        return conditions ? [] : ["Safety is disabled."];
+    return conditions.flatMap(([expected, condition], index) => {
+        const errors = getConditionErrors(condition, metadata, files);
+        if (!errors.length === expected)
+            return [];
+        if (expected)
+            return errors;
+        return [`Safety condition ${index + 1} unexpectedly matched.`];
+    });
+}
 export async function checkPr() {
     this.context.abort.throwIfAborted();
     await this.updateState({ status: "running" });
@@ -31,26 +90,7 @@ export async function checkPr() {
         throw new MagiError("blocked", `PR is not open.`);
     if (metadata.draft)
         throw new MagiError("blocked", `PR is a draft.`);
-    const errors = [];
-    if (this.config.review.safety.allowAuthors.length)
-        if (!this.config.review.safety.allowAuthors.includes(metadata.user.login))
-            errors.push(`Author is not allowed: ${metadata.user.login}.`);
-    if (this.config.review.safety.requiredLabels.length) {
-        const missingLabels = this.config.review.safety.requiredLabels.filter((label) => !metadata.labels.some(({ name }) => name === label));
-        if (missingLabels.length)
-            errors.push(`Required labels missing: ${missingLabels.join(", ")}.`);
-    }
-    if (isNumber(this.config.review.safety.maxChangedFiles) &&
-        metadata.changed_files > this.config.review.safety.maxChangedFiles)
-        errors.push(`Changed files exceed limit: ${metadata.changed_files} > ${this.config.review.safety.maxChangedFiles}.`);
-    if (this.config.review.safety.blockedPaths.length) {
-        const isBlocked = picomatch(this.config.review.safety.blockedPaths, {
-            dot: true,
-        });
-        const blocked = files.filter((file) => isBlocked(file));
-        if (blocked.length)
-            errors.push(`Blocked paths changed: ${blocked.join(", ")}.`);
-    }
+    const errors = getSafetyErrors(this.config.review.safety, metadata, files);
     if (errors.length)
         throw new MagiError("blocked", `PR is safety blocked. ${errors.join(" ")}`);
     if (this.config.mode === "single") {

package/dist/tools/review/context.js

@@ -69,8 +69,6 @@ export async function checkExistingReviews() {
     for (const [id, reviewer] of Object.entries(reviewers)) {
         if (reviewer.status !== "skip")
             continue;
-        if (!reviewer.review)
-            throw new MagiError("blocked", `No review found for reviewer ${id}.`);
         const single = this.config.mode === "single";
         const author = single ? this.config.account : reviewer.account;
         const hasUserReply = threads.some(({ comments, isResolved }) => {
@@ -86,7 +84,7 @@ export async function checkExistingReviews() {
             const last = comments.at(-1);
             return (!!last &&
                 last.author?.login !== author &&
-                (!reviewer.review?.submitted_at ||
+                (!reviewer.review.submitted_at ||
                     last.createdAt.localeCompare(reviewer.review.submitted_at) > 0));
         });
         if (hasUserReply) {
@@ -243,8 +241,6 @@ export async function getInlineCommentTargets() {
     return inlineCommentTargets;
 }
 async function hasCommit(sha) {
-    if (!this.state.worktree)
-        throw new MagiError("blocked", "PR worktree not found.");
     try {
         await this.exec(command("git", "cat-file", "-e", quote(`${sha}^{commit}`)), {
             cwd: this.state.worktree.path,

package/dist/tools/review/review.js

@@ -1,7 +1,7 @@
 import { join } from "node:path";
 import { MagiError } from "@/magi";
 import { createExecWithGitHubApiRetry, quote } from "@/utils";
-import { automate, postReviews } from "./action";
+import { automate, isAutomationEnabled, postReviews } from "./action";
 import { checkCi, checkPr, classifyChecks, rerunChecks } from "./check";
 import { checkExistingReviews, fetchReviewContext } from "./context";
 import { createReport } from "./report";
@@ -62,6 +62,7 @@ export class Review {
     validateFindings = validateFindings;
     reconsiderClose = reconsiderClose;
     postReviews = postReviews;
+    isAutomationEnabled = isAutomationEnabled;
     automate = automate;
     createReport = createReport;
     async cleanup() {

package/dist/utils/function.js

@@ -12,6 +12,15 @@ export function wait(ms = 0, signal) {
         signal?.addEventListener("abort", abort, { once: true });
     });
 }
+export async function ignoreError(cb, shouldIgnore) {
+    try {
+        return await cb();
+    }
+    catch (e) {
+        if (!shouldIgnore(e))
+            throw e;
+    }
+}
 export async function loop(cb, ms = 0) {
     for (;;) {
         const value = await cb();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",
@@ -28,40 +28,40 @@
     "schema.json"
   ],
   "dependencies": {
-    "@opencode-ai/plugin": "^1.18.1",
-    "@opencode-ai/sdk": "^1.18.1",
+    "@opencode-ai/plugin": "^1.18.4",
+    "@opencode-ai/sdk": "^1.18.4",
     "ajv": "^8.20.0",
-    "graphql": "^16.14.0",
-    "graphql-tag": "^2.12.6",
+    "graphql": "^17.0.2",
+    "graphql-tag": "^2.12.7",
     "octokit": "^5.0.5",
-    "picomatch": "^4.0.4",
-    "valibot": "^1.4.1"
+    "picomatch": "^4.0.5",
+    "valibot": "^1.4.2"
   },
   "devDependencies": {
     "@changesets/changelog-github": "^0.7.0",
-    "@changesets/cli": "^2.30.0",
-    "@commitlint/cli": "^21.0.1",
-    "@commitlint/config-conventional": "^21.0.1",
-    "@graphql-codegen/cli": "^7.1.1",
+    "@changesets/cli": "^2.31.1",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@graphql-codegen/cli": "^7.2.0",
     "@graphql-codegen/typescript-generic-sdk": "^5.0.1",
-    "@graphql-codegen/typescript-operations": "^6.0.3",
+    "@graphql-codegen/typescript-operations": "^6.1.1",
     "@limegrass/eslint-plugin-import-alias": "^1.6.1",
     "@octokit/graphql-schema": "^15.26.1",
     "@octokit/plugin-throttling": "^11.0.3",
     "@stylistic/eslint-plugin": "^5.10.0",
-    "@types/node": "^25.9.1",
+    "@types/node": "^26.1.1",
     "@types/picomatch": "^4.0.3",
-    "@typescript/native-preview": "7.0.0-dev.20260525.1",
-    "@vitest/coverage-v8": "^4.1.7",
-    "@vitest/ui": "^4.1.7",
-    "eslint-plugin-perfectionist": "^5.9.0",
+    "@typescript/native-preview": "7.0.0-dev.20260707.2",
+    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/ui": "^4.1.10",
+    "eslint-plugin-perfectionist": "^5.10.0",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "lefthook": "^2.1.8",
-    "oxfmt": "^0.51.0",
-    "oxlint": "^1.66.0",
-    "oxlint-tsgolint": "^0.23.0",
+    "lefthook": "^2.1.10",
+    "oxfmt": "^0.60.0",
+    "oxlint": "^1.75.0",
+    "oxlint-tsgolint": "^7.0.2001",
     "rimraf": "^6.1.3",
-    "vitest": "^4.1.7"
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "clean": "rimraf node_modules dist coverage",
@@ -74,6 +74,7 @@
     "lint:fix": "oxlint . --max-warnings=0 --fix",
     "type:check": "tsgo --noEmit",
     "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --coverage.reporter=html && open coverage/index.html",
     "test:dev": "vitest --watch --ui --passWithNoTests",
     "quality": "pnpm format:check && pnpm lint:check && pnpm type:check && pnpm test",
     "release": "changeset publish",

package/schema.json

@@ -174,21 +174,125 @@
         "variant": { "type": "string" }
       }
     },
+    "safetyFilter": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "exclude": { "type": "array", "items": { "type": "string" } },
+        "include": { "type": "array", "items": { "type": "string" } }
+      }
+    },
+    "safetyBranchFilter": {
+      "type": "object",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "properties": {
+        "base": { "$ref": "#/$defs/safetyFilter" },
+        "head": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "safety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "maxChangedFiles": { "type": "integer", "minimum": 0 },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "conditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [{ "type": "boolean" }, { "$ref": "#/$defs/safety" }]
+          }
+        }
+      ]
+    },
+    "automationSafety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
+    "automationConditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [
+              { "type": "boolean" },
+              { "$ref": "#/$defs/automationSafety" }
+            ]
+          }
+        }
+      ]
+    },
+    "mergeAutomationConditions": {
+      "oneOf": [
+        { "type": "boolean" },
+        {
+          "type": "array",
+          "items": {
+            "type": "array",
+            "minItems": 2,
+            "maxItems": 2,
+            "prefixItems": [
+              { "type": "boolean" },
+              { "$ref": "#/$defs/mergeAutomationSafety" }
+            ]
+          }
+        }
+      ]
+    },
+    "mergeAutomationSafety": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "authors": { "$ref": "#/$defs/safetyFilter" },
+        "branches": { "$ref": "#/$defs/safetyBranchFilter" },
+        "edited": { "type": "boolean" },
+        "labels": { "$ref": "#/$defs/safetyFilter" },
+        "paths": { "$ref": "#/$defs/safetyFilter" }
+      }
+    },
     "automation": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "merge": { "type": "boolean", "default": true },
-        "close": { "type": "boolean" }
+        "merge": { "$ref": "#/$defs/automationConditions", "default": true },
+        "close": { "$ref": "#/$defs/automationConditions", "default": false }
       }
     },
     "mergeAutomation": {
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "merge": { "type": "boolean", "default": true },
-        "close": { "type": "boolean", "default": false },
-        "conflict": { "type": "boolean", "default": false }
+        "merge": {
+          "$ref": "#/$defs/mergeAutomationConditions",
+          "default": true
+        },
+        "close": {
+          "$ref": "#/$defs/mergeAutomationConditions",
+          "default": false
+        },
+        "conflict": { "$ref": "#/$defs/automationConditions", "default": false }
       }
     },
     "reviewChecks": {
@@ -222,16 +326,6 @@
         "runs": { "type": "integer", "minimum": 1, "default": 3 }
       }
     },
-    "safety": {
-      "type": "object",
-      "additionalProperties": false,
-      "properties": {
-        "allowAuthors": { "type": "array", "items": { "type": "string" } },
-        "blockedPaths": { "type": "array", "items": { "type": "string" } },
-        "maxChangedFiles": { "type": "integer", "minimum": 0 },
-        "requiredLabels": { "type": "array", "items": { "type": "string" } }
-      }
-    },
     "reviewPrompts": {
       "type": "object",
       "additionalProperties": false,
@@ -376,7 +470,7 @@
         },
         "prompts": { "$ref": "#/$defs/reviewPrompts" },
         "checks": { "$ref": "#/$defs/reviewChecks" },
-        "safety": { "$ref": "#/$defs/safety" },
+        "safety": { "$ref": "#/$defs/conditions" },
         "automation": { "$ref": "#/$defs/automation" },
         "concurrency": { "$ref": "#/$defs/concurrency" },
         "merge": { "$ref": "#/$defs/reviewMerge" },