opencode-magi 0.0.0-dev-20260520165753 → 0.0.0-dev-20260520173258

package/dist/config/resolve.js

@@ -4,6 +4,26 @@ const ID_PATTERN = /^[A-Za-z0-9_-]+$/;
 const DEFAULT_COMMON_PERMISSION = commonPermission;
 const DEFAULT_REVIEWER_PERMISSION = DEFAULT_COMMON_PERMISSION;
 const DEFAULT_EDITOR_PERMISSION = mergePermissions(DEFAULT_COMMON_PERMISSION, editorPermission);
+const DEFAULT_TRIAGE_CATEGORIES = [
+    {
+        description: "Something is broken or behaves incorrectly.",
+        id: "bug",
+        labels: ["bug"],
+        types: ["Bug"],
+    },
+    {
+        description: "Maintenance, refactoring, chores, or planned work.",
+        id: "task",
+        labels: ["task"],
+        types: ["Task"],
+    },
+    {
+        description: "New or improved user-facing capability.",
+        id: "feature",
+        labels: ["enhancement"],
+        types: ["Feature"],
+    },
+];
 export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
@@ -90,6 +110,14 @@ export function resolveAgents(config) {
             : undefined,
     };
 }
+function resolveTriageCategories(config) {
+    return (config.triage?.categories ?? DEFAULT_TRIAGE_CATEGORIES).map((category) => ({
+        description: category.description,
+        id: category.id ?? "",
+        labels: category.labels ?? [],
+        types: category.types ?? [],
+    }));
+}
 export function resolveRepository(config) {
     if (!config.github?.owner)
         throw new Error("github.owner is required");
@@ -157,19 +185,10 @@ export function resolveRepository(config) {
                 close: config.triage?.automation?.close ?? false,
                 pr: config.triage?.automation?.pr ?? false,
             },
+            categories: resolveTriageCategories(config),
             concurrency: {
                 runs: config.triage?.concurrency?.runs ?? 3,
             },
-            kind: {
-                bug: {
-                    label: config.triage?.kind?.bug?.label ?? ["bug"],
-                    type: config.triage?.kind?.bug?.type ?? ["Bug"],
-                },
-                feature: {
-                    label: config.triage?.kind?.feature?.label ?? ["enhancement"],
-                    type: config.triage?.kind?.feature?.type ?? ["Feature"],
-                },
-            },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
             safety: {

package/dist/config/validate.js

@@ -9,6 +9,8 @@ const RESERVED_REVIEWER_KEYS = new Set(["editor", "orchestrator", "system"]);
 const PERMISSION_ACTIONS = new Set(["allow", "ask", "deny"]);
 const AJV = new Ajv2020({ allErrors: true, strict: false });
 const validateSchema = AJV.compile(schema);
+const TRIAGE_CATEGORY_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
+const RESERVED_TRIAGE_CATEGORY_IDS = new Set(["ASK", "none"]);
 const CONFIG_KEYS = new Set([
     "$schema",
     "agents",
@@ -76,9 +78,9 @@ const TRIAGE_KEYS = new Set([
     "account",
     "agents",
     "automation",
+    "categories",
     "concurrency",
     "creator",
-    "kind",
     "output",
     "prompts",
     "safety",
@@ -98,9 +100,8 @@ const CLEAR_KEYS = new Set(["branch", "output", "session", "worktree"]);
 const CONCURRENCY_KEYS = new Set(["reviewers", "runs"]);
 const OUTPUT_KEYS = new Set(["repairAttempts"]);
 const TRIAGE_AUTOMATION_KEYS = new Set(["clear", "close", "pr"]);
+const TRIAGE_CATEGORY_KEYS = new Set(["description", "id", "labels", "types"]);
 const TRIAGE_CONCURRENCY_KEYS = new Set(["runs"]);
-const TRIAGE_KIND_KEYS = new Set(["bug", "feature"]);
-const TRIAGE_KIND_RULE_KEYS = new Set(["label", "type"]);
 const TRIAGE_SAFETY_KEYS = new Set([
     "allowAuthors",
     "allowMentionActors",
@@ -129,14 +130,13 @@ const MERGE_PROMPT_KEYS = new Set([
 ]);
 const TRIAGE_PROMPT_KEYS = new Set([
     "action",
-    "bug",
+    "acceptance",
+    "category",
     "comment",
     "commentClassification",
     "createPr",
     "duplicate",
     "existingPr",
-    "feature",
-    "kind",
     "question",
     "reconsider",
 ]);
@@ -536,16 +536,44 @@ function validateStringArray(value, path, errors) {
             errors.push(`${path}[${index}] must be a string`);
     });
 }
-function validateStringArrayObject(value, path, keys, errors) {
-    if (value == null)
+function validateTriageCategories(categories, path, errors) {
+    if (categories == null)
         return;
-    if (!isPlainObject(value)) {
-        errors.push(`${path} must be an object`);
+    if (!Array.isArray(categories)) {
+        errors.push(`${path} must be an array`);
         return;
     }
-    validateKnownKeys(value, path, keys, errors);
-    for (const key of keys)
-        validateStringArray(value[key], `${path}.${key}`, errors);
+    const ids = new Set();
+    categories.forEach((item, index) => {
+        const itemPath = `${path}[${index}]`;
+        if (!isPlainObject(item)) {
+            errors.push(`${itemPath} must be an object`);
+            return;
+        }
+        const category = item;
+        validateKnownKeys(category, itemPath, TRIAGE_CATEGORY_KEYS, errors);
+        if (!category.id) {
+            errors.push(`${itemPath}.id is required`);
+        }
+        else if (typeof category.id !== "string") {
+            errors.push(`${itemPath}.id must be a string`);
+        }
+        else if (!TRIAGE_CATEGORY_ID_PATTERN.test(category.id)) {
+            errors.push(`${itemPath}.id must match /^[A-Za-z0-9_-]+$/`);
+        }
+        else if (RESERVED_TRIAGE_CATEGORY_IDS.has(category.id)) {
+            errors.push(`${itemPath}.id is reserved: ${category.id}`);
+        }
+        else if (ids.has(category.id)) {
+            errors.push(`${itemPath}.id must be unique`);
+        }
+        else {
+            ids.add(category.id);
+        }
+        validateStringArray(category.labels, `${itemPath}.labels`, errors);
+        validateStringArray(category.types, `${itemPath}.types`, errors);
+        validateString(category.description, `${itemPath}.description`, errors);
+    });
 }
 function validateSafety(config, errors) {
     const safety = config.review?.safety;
@@ -587,7 +615,6 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
-    const kind = triage.kind;
     const safety = triage.safety;
     if (!triage.account)
         errors.push("triage.account is required");
@@ -615,9 +642,7 @@ function validateTriage(config, errors, options) {
             concurrency.runs < 1)) {
         errors.push("triage.concurrency.runs must be a positive integer");
     }
-    validateKnownKeys(kind, "triage.kind", TRIAGE_KIND_KEYS, errors);
-    validateStringArrayObject(kind?.bug, "triage.kind.bug", TRIAGE_KIND_RULE_KEYS, errors);
-    validateStringArrayObject(kind?.feature, "triage.kind.feature", TRIAGE_KIND_RULE_KEYS, errors);
+    validateTriageCategories(triage.categories, "triage.categories", errors);
     validateKnownKeys(safety, "triage.safety", TRIAGE_SAFETY_KEYS, errors);
     validateStringArray(safety?.allowAuthors, "triage.safety.allowAuthors", errors);
     validateStringArray(safety?.allowMentionActors, "triage.safety.allowMentionActors", errors);

package/dist/github/commands.js

@@ -102,9 +102,24 @@ async function fetchPullRequestQueueInput(exec, repository, pr, token) {
     return { headRefOid: pullRequest.headRefOid, id: pullRequest.id };
 }
 export async function fetchPullRequest(exec, repository, pr) {
-    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,url,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner`);
+    const json = await exec(`gh pr view ${pr} --repo ${shellQuote(repoSpecifier(repository))} --json number,title,body,url,state,author,isDraft,baseRefOid,headRefOid,baseRefName,headRefName,headRepository,headRepositoryOwner,changedFiles`);
     return JSON.parse(json);
 }
+export async function fetchPullRequestClosingIssues(exec, repository, pr) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { closingIssuesReferences(first: 20) { nodes { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
+    const data = JSON.parse(raw);
+    return (data.data?.repository?.pullRequest?.closingIssuesReferences?.nodes?.map((issue) => ({
+        author: issue.author?.login ?? "",
+        body: issue.body ?? "",
+        labels: issue.labels?.nodes?.map((label) => label.name) ?? [],
+        number: issue.number,
+        state: issue.state,
+        title: issue.title,
+        type: issue.issueType?.name,
+        url: issue.url,
+    })) ?? []);
+}
 export async function fetchIssue(exec, repository, issue) {
     const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { number title body url state author { login } labels(first: 100) { nodes { name } } issueType { name } } } }`;
     try {
@@ -142,17 +157,47 @@ async function fetchIssueWithCli(exec, repository, issue) {
     };
 }
 export async function fetchIssueComments(exec, repository, issue, limit = 50) {
-    const query = `query($owner: String!, $repo: String!, $issue: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { comments(last: $limit) { nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
+    return (await fetchIssueCommentPage(exec, repository, issue, limit)).comments;
+}
+export async function fetchIssueCommentPage(exec, repository, issue, limit = 50) {
+    const query = `query($owner: String!, $repo: String!, $issue: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
     const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F issue=${issue} -F limit=${limit}`);
     const data = JSON.parse(raw);
-    return (data.data?.repository?.issue?.comments?.nodes?.map((comment) => ({
+    const connection = data.data?.repository?.issue?.comments;
+    const comments = connection?.nodes?.map((comment) => ({
         author: comment.author?.login ?? "",
         authorAssociation: comment.authorAssociation,
         body: comment.body ?? "",
         createdAt: comment.createdAt,
         id: comment.databaseId,
         url: comment.url,
-    })) ?? []);
+    })) ?? [];
+    return {
+        comments,
+        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
+    };
+}
+export async function fetchPullRequestComments(exec, repository, pr, limit = 50) {
+    return (await fetchPullRequestCommentPage(exec, repository, pr, limit))
+        .comments;
+}
+export async function fetchPullRequestCommentPage(exec, repository, pr, limit = 50) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $limit: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { comments(last: $limit) { totalCount nodes { databaseId author { login } authorAssociation body createdAt url } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F limit=${limit}`);
+    const data = JSON.parse(raw);
+    const connection = data.data?.repository?.pullRequest?.comments;
+    const comments = connection?.nodes?.map((comment) => ({
+        author: comment.author?.login ?? "",
+        authorAssociation: comment.authorAssociation,
+        body: comment.body ?? "",
+        createdAt: comment.createdAt,
+        id: comment.databaseId,
+        url: comment.url,
+    })) ?? [];
+    return {
+        comments,
+        omitted: Math.max(0, (connection?.totalCount ?? comments.length) - comments.length),
+    };
 }
 export async function fetchRelatedPullRequests(exec, repository, issue) {
     const query = `query($owner: String!, $repo: String!, $issue: Int!) { repository(owner: $owner, name: $repo) { issue(number: $issue) { timelineItems(first: 50, itemTypes: [CONNECTED_EVENT, CROSS_REFERENCED_EVENT]) { nodes { __typename ... on ConnectedEvent { subject { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } ... on CrossReferencedEvent { source { __typename ... on PullRequest { number title url state mergedAt body author { login } } } } } } } } }`;
@@ -295,7 +340,7 @@ export async function fetchPullRequestCommits(exec, repository, pr) {
     }));
 }
 export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { author { login } changedFiles labels(first: 100) { nodes { name } } files(first: 100, after: $filesCursor) { nodes { path } pageInfo { hasNextPage endCursor } } } } } }`;
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $filesCursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { author { login } changedFiles labels(first: 100) { nodes { name } } files(first: 100, after: $filesCursor) { nodes { path } pageInfo { hasNextPage endCursor } } } } }`;
     const files = [];
     let author = "";
     let changedFiles = 0;
@@ -467,11 +512,19 @@ function findingComment(finding) {
     }
     return comment;
 }
-export async function postChangesRequested(exec, repository, pr, account, findings) {
+function requirementFindingSummary(finding) {
+    return [
+        `- Missing issue #${finding.issueNumber} requirement: ${finding.requirement}`,
+        `  Evidence: ${finding.evidence}`,
+        `  Fix: ${finding.fix}`,
+    ].join("\n");
+}
+export async function postChangesRequested(exec, repository, pr, account, findings, requirementFindings = []) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-review-${process.pid}-${Date.now()}.json`);
     const body = findings
         .map((finding) => `- ${finding.issue.split("\n")[0]}`)
+        .concat(requirementFindings.map(requirementFindingSummary))
         .join("\n");
     await writeFile(payloadPath, JSON.stringify({
         body,
@@ -610,6 +663,45 @@ export async function fetchUnresolvedThreads(exec, repository, pr, author) {
         ];
     });
 }
+export async function fetchPullRequestReviewThreads(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
+    return (await fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit, commentsPerThread)).threads;
+}
+export async function fetchPullRequestReviewThreadPage(exec, repository, pr, threadLimit = 50, commentsPerThread = 20) {
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $threadLimit: Int!, $commentsPerThread: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(last: $threadLimit) { totalCount nodes { id isResolved comments(last: $commentsPerThread) { totalCount nodes { databaseId author { login } path line body createdAt } } } } } } }`;
+    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr} -F threadLimit=${threadLimit} -F commentsPerThread=${commentsPerThread}`);
+    const data = JSON.parse(raw);
+    const connection = data.data?.repository?.pullRequest?.reviewThreads;
+    const nodes = connection?.nodes ?? [];
+    const threads = nodes.flatMap((thread) => {
+        const comments = [...thread.comments.nodes]
+            .sort((a, b) => a.createdAt.localeCompare(b.createdAt))
+            .map((comment) => ({
+            author: comment.author?.login ?? "",
+            body: comment.body ?? "",
+            commentId: comment.databaseId,
+            createdAt: comment.createdAt,
+        }));
+        const first = thread.comments.nodes[0];
+        if (!first)
+            return [];
+        return [
+            {
+                body: first.body ?? "",
+                commentId: first.databaseId,
+                comments,
+                isResolved: thread.isResolved,
+                line: first.line,
+                omittedComments: Math.max(0, (thread.comments.totalCount ?? comments.length) - comments.length),
+                path: first.path,
+                threadId: thread.id,
+            },
+        ];
+    });
+    return {
+        omitted: Math.max(0, (connection?.totalCount ?? threads.length) - threads.length),
+        threads,
+    };
+}
 export async function postReply(exec, repository, pr, account, commentId, body) {
     const token = await ghToken(exec, repository, account);
     const payloadPath = join(tmpdir(), `magi-reply-${process.pid}-${Date.now()}-${commentId}.json`);

package/dist/index.js

@@ -91,27 +91,133 @@ export function parseIssues(value) {
         throw new Error("Specify one or more issue numbers or issue URLs.");
     return issues;
 }
-export function parseRunArguments(value, dryRun = false) {
+export function parseRunArguments(value, dryRun = false, command = "review") {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
-    const prTokens = tokens.filter((token) => {
+    const configOverrides = {};
+    const prTokens = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
-            return false;
+            continue;
         }
-        return true;
-    });
-    return { dryRun, prs: parsePrs(prTokens.join(" ")) };
+        switch (token) {
+            case "--language":
+                setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
+                break;
+            case "--merge":
+            case "--no-merge":
+                setConfigOverride(configOverrides, [command, "automation", "merge"], token === "--merge");
+                break;
+            case "--close":
+            case "--no-close":
+                setConfigOverride(configOverrides, [command, "automation", "close"], token === "--close");
+                break;
+            case "--max-cycles":
+                if (command !== "merge")
+                    throw unsupportedFlag(token, command);
+                setConfigOverride(configOverrides, ["merge", "maxThreadResolutionCycles"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0));
+                break;
+            case "--retry-failed-jobs":
+                setConfigOverride(configOverrides, ["review", "checks", "retryFailedJobs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0));
+                break;
+            case "--reviewer-concurrency":
+                setConfigOverride(configOverrides, ["review", "concurrency", "reviewers"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--run-concurrency":
+                setConfigOverride(configOverrides, ["review", "concurrency", "runs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--wait-checks":
+            case "--no-wait-checks":
+                setConfigOverride(configOverrides, ["review", "checks", "wait"], token === "--wait-checks");
+                break;
+            case "--wait-checks-after-edit":
+            case "--no-wait-checks-after-edit":
+                if (command !== "merge")
+                    throw unsupportedFlag(token, command);
+                setConfigOverride(configOverrides, ["merge", "checks", "wait"], token === "--wait-checks-after-edit");
+                break;
+            case "--pr":
+            case "--no-pr":
+                throw unsupportedFlag(token, command);
+            default:
+                if (token.startsWith("--"))
+                    throw unsupportedFlag(token, command);
+                prTokens.push(token);
+        }
+    }
+    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")) };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
-    const issueTokens = tokens.filter((token) => {
+    const configOverrides = {};
+    const issueTokens = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
-            return false;
+            continue;
         }
-        return true;
-    });
-    return { dryRun, issues: parseIssues(issueTokens.join(" ")) };
+        switch (token) {
+            case "--language":
+                setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
+                break;
+            case "--close":
+            case "--no-close":
+                setConfigOverride(configOverrides, ["triage", "automation", "close"], token === "--close");
+                break;
+            case "--pr":
+            case "--no-pr":
+                setConfigOverride(configOverrides, ["triage", "automation", "pr"], token === "--pr");
+                break;
+            case "--run-concurrency":
+                setConfigOverride(configOverrides, ["triage", "concurrency", "runs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            case "--merge":
+            case "--no-merge":
+            case "--max-cycles":
+            case "--retry-failed-jobs":
+            case "--reviewer-concurrency":
+            case "--wait-checks":
+            case "--no-wait-checks":
+            case "--wait-checks-after-edit":
+            case "--no-wait-checks-after-edit":
+                throw unsupportedFlag(token, "triage");
+            default:
+                if (token.startsWith("--"))
+                    throw unsupportedFlag(token, "triage");
+                issueTokens.push(token);
+        }
+    }
+    return { configOverrides, dryRun, issues: parseIssues(issueTokens.join(" ")) };
+}
+function nextFlagValue(tokens, index, flag) {
+    const value = tokens[index];
+    if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value.`);
+    return value;
+}
+function parseIntegerFlag(value, flag, minimum) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) ||
+        String(parsed) !== value ||
+        parsed < minimum) {
+        throw new Error(`${flag} must be an integer greater than or equal to ${minimum}.`);
+    }
+    return parsed;
+}
+function setConfigOverride(target, path, value) {
+    let current = target;
+    for (const key of path.slice(0, -1)) {
+        const existing = current[key];
+        const next = isPlainObject(existing) ? existing : {};
+        current[key] = next;
+        current = next;
+    }
+    current[path[path.length - 1]] = value;
+}
+function unsupportedFlag(flag, command) {
+    return new Error(`${flag} is not supported for /magi:${command}.`);
 }
 function parseOptionalPr(value) {
     if (!value?.trim())
@@ -322,10 +428,11 @@ export const MagiPlugin = async ({ client, directory }) => {
                     dryRun: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
-                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
+                    const parsed = parseRunArguments(args.prs, args.dryRun ?? false, "merge");
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -334,9 +441,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         repository,
                         pr,
@@ -360,8 +467,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -369,9 +477,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         repository,
                         pr,
@@ -392,8 +500,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args, context) {
                     const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
                     const loaded = await loadConfig(directory);
-                    const retryingExec = withGitHubApiRetry(exec, loaded.config.github?.apiRetryAttempts ?? 3);
-                    const validation = await validateConfig(loaded.config, {
+                    const config = mergeMagiConfig(loaded.config, parsed.configOverrides);
+                    const retryingExec = withGitHubApiRetry(exec, config.github?.apiRetryAttempts ?? 3);
+                    const validation = await validateConfig(config, {
                         checkAuth: true,
                         directory,
                         exec: retryingExec,
@@ -403,11 +512,11 @@ export const MagiPlugin = async ({ client, directory }) => {
                     });
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
-                    const repository = resolveRepository(loaded.config);
+                    const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
                     const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
-                        config: loaded.config,
+                        config,
                         dryRun: parsed.dryRun,
                         issue,
                         parentSessionId: context.sessionID,

package/dist/orchestrator/findings.js

@@ -58,9 +58,10 @@ export function applyFindingValidation(input) {
             discarded.push(target);
             return false;
         });
-        next[reviewer] = findings.length
-            ? { ...output, findings }
-            : { findings: [], verdict: "MERGE" };
+        next[reviewer] =
+            findings.length || output.requirementFindings.length
+                ? { ...output, findings }
+                : { findings: [], requirementFindings: [], verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/report.js

@@ -27,6 +27,9 @@ function formatRereviewFinding(finding) {
         : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.body}`;
 }
+function formatRequirementFinding(finding) {
+    return `Issue #${finding.issueNumber}: ${finding.requirement}`;
+}
 function isReviewOutput(output) {
     return "findings" in output;
 }
@@ -78,7 +81,10 @@ function reviewerDetailLines(output) {
             return output.reason ? [output.reason] : [];
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return output.findings.map(formatFinding);
+        return [
+            ...output.findings.map(formatFinding),
+            ...output.requirementFindings.map(formatRequirementFinding),
+        ];
     }
     if (output.verdict === "CLOSE")
         return output.reason ? [output.reason] : [];
@@ -86,6 +92,7 @@ function reviewerDetailLines(output) {
         return [];
     return [
         ...output.newFindings.map(formatRereviewFinding),
+        ...output.requirementFindings.map(formatRequirementFinding),
         ...output.followUps.map((item) => `Comment #${item.commentId}: ${item.body}`),
     ];
 }