opencode-magi 0.3.0 → 0.4.0

package/dist/config/validate.js

@@ -157,6 +157,56 @@ function ghHostOption(config) {
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
+function expandAgentRefUse(value, path, refs, refsInvalid, errors) {
+    if (!isPlainObject(value) || !Object.hasOwn(value, "ref"))
+        return value;
+    const use = { ...value };
+    const ref = use.ref;
+    delete use.ref;
+    if (typeof ref !== "string") {
+        errors.push(`${path}.ref must be a string`);
+        return use;
+    }
+    if (refsInvalid) {
+        errors.push(`agents.refs must be an object to resolve ${path}.ref`);
+        return use;
+    }
+    const preset = refs?.[ref];
+    if (preset == null) {
+        errors.push(`${path}.ref references unknown agents.refs preset: ${ref}`);
+        return use;
+    }
+    if (!isPlainObject(preset)) {
+        errors.push(`agents.refs.${ref} must be an object when referenced by ${path}.ref`);
+        return use;
+    }
+    const presetFields = { ...preset };
+    delete presetFields.ref;
+    return { ...presetFields, ...use };
+}
+function expandAgentRefs(config, errors) {
+    if (!config || typeof config !== "object")
+        return;
+    const magiConfig = config;
+    const agents = magiConfig.agents;
+    const refsValue = isPlainObject(agents) ? agents.refs : undefined;
+    const refsInvalid = refsValue != null && !isPlainObject(refsValue);
+    const refs = isPlainObject(refsValue) ? refsValue : undefined;
+    if (Array.isArray(magiConfig.review?.agents)) {
+        magiConfig.review.agents = magiConfig.review.agents.map((agent, index) => expandAgentRefUse(agent, `review.agents[${index}]`, refs, refsInvalid, errors));
+    }
+    if (isPlainObject(magiConfig.merge?.editor)) {
+        magiConfig.merge.editor = expandAgentRefUse(magiConfig.merge.editor, "merge.editor", refs, refsInvalid, errors);
+    }
+    if (Array.isArray(magiConfig.triage?.agents)) {
+        magiConfig.triage.agents = magiConfig.triage.agents.map((agent, index) => expandAgentRefUse(agent, `triage.agents[${index}]`, refs, refsInvalid, errors));
+    }
+    if (isPlainObject(magiConfig.triage?.creator)) {
+        magiConfig.triage.creator = expandAgentRefUse(magiConfig.triage.creator, "triage.creator", refs, refsInvalid, errors);
+    }
+    if (isPlainObject(magiConfig.agents))
+        delete magiConfig.agents.refs;
+}
 function validateKnownKeys(value, path, keys, errors) {
     if (!isPlainObject(value))
         return;
@@ -792,6 +842,7 @@ export async function validateConfig(config, options = {}) {
     const warnings = [];
     if (!config || typeof config !== "object")
         errors.push("config must be an object");
+    expandAgentRefs(config, errors);
     if (config && typeof config === "object")
         validateJsonSchema(config, errors);
     validateKnownKeys(config, "config", CONFIG_KEYS, errors);

package/dist/github/commands.js

@@ -509,6 +509,9 @@ export async function postCloseComment(exec, repository, pr, account, body) {
         await rm(payloadPath, { force: true });
     }
 }
+function isInlineFinding(finding) {
+    return finding.line != null;
+}
 function findingComment(finding) {
     const comment = {
         body: `**Issue:** ${finding.issue}\n\n**Fix:** ${finding.fix}`,
@@ -529,16 +532,47 @@ function requirementFindingSummary(finding) {
         `  Fix: ${finding.fix}`,
     ].join("\n");
 }
+function findingLocation(finding) {
+    if (finding.line == null)
+        return finding.path;
+    if (finding.startLine == null)
+        return `${finding.path}:${finding.line}`;
+    return `${finding.path}:${finding.startLine}-${finding.line}`;
+}
+function findingSummary(finding) {
+    return [
+        `- ${findingLocation(finding)}: ${finding.issue}`,
+        `  Fix: ${finding.fix}`,
+    ]
+        .filter(Boolean)
+        .join("\n");
+}
+function changesRequestedBody(findings, requirementFindings) {
+    const inlineFindings = findings.filter(isInlineFinding);
+    const fileLevelFindings = findings.filter((finding) => !isInlineFinding(finding));
+    const sections = [];
+    if (inlineFindings.length) {
+        sections.push(["Inline findings:", ...inlineFindings.map(findingSummary)].join("\n"));
+    }
+    if (fileLevelFindings.length) {
+        sections.push(["File-level findings:", ...fileLevelFindings.map(findingSummary)].join("\n"));
+    }
+    if (requirementFindings.length) {
+        sections.push([
+            "Requirement findings:",
+            ...requirementFindings.map(requirementFindingSummary),
+        ].join("\n"));
+    }
+    return sections.join("\n\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");
+    const inlineFindings = findings.filter(isInlineFinding);
+    const body = changesRequestedBody(findings, requirementFindings);
     await writeFile(payloadPath, JSON.stringify({
         body,
-        comments: findings.map(findingComment),
+        comments: inlineFindings.map(findingComment),
         event: "REQUEST_CHANGES",
     }));
     try {

package/dist/orchestrator/inline-comments.js

@@ -52,6 +52,12 @@ function assertPositiveInteger(value, name) {
 export function validateInlineCommentTargets(findings, targets, label = "findings") {
     for (const [index, finding] of findings.entries()) {
         const name = `${label}[${index}]`;
+        if (finding.line == null) {
+            if (finding.startLine != null) {
+                throw new Error(`${name}.startLine requires line`);
+            }
+            continue;
+        }
         assertPositiveInteger(finding.line, `${name}.line`);
         if (finding.startLine != null) {
             assertPositiveInteger(finding.startLine, `${name}.startLine`);

package/dist/orchestrator/merge.js

@@ -50,7 +50,7 @@ async function withReviewerFailureProgress(input) {
         throw error;
     }
 }
-async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
+async function runEditor(input, worktreePath, cycle, reviewFindings, unresolvedThreads) {
     const editor = input.repository.agents.editor;
     if (!editor)
         throw new Error("agents.editor is required for magi_merge");
@@ -64,6 +64,7 @@ async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
         directory: input.directory,
         pr: input.pr,
         repository: input.repository,
+        reviewFindings: JSON.stringify(reviewFindings, null, 2),
         unresolvedThreads: JSON.stringify(unresolvedThreads, null, 2),
         worktreePath,
     });
@@ -145,14 +146,14 @@ async function postRereviewOutput(input, reviewerKey, output) {
     if (output.verdict === "CLOSE") {
         return postCloseComment(input.exec, input.repository, input.pr, reviewer.account, output.reason ?? "Close requested.");
     }
-    if (output.newFindings.length) {
+    if (output.newFindings.length || output.requirementFindings.length) {
         return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
             fix: "Please address this before merging.",
             issue: finding.body,
-            line: finding.line,
             path: finding.path,
+            ...(finding.line == null ? {} : { line: finding.line }),
             startLine: finding.startLine,
-        })));
+        })), output.requirementFindings);
     }
     return replies[0] ?? "";
 }
@@ -161,6 +162,51 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
     validateInlineCommentTargets(output.newFindings, targets, "newFindings");
     return output;
 }
+function newFindingToEditorFinding(reviewer, finding) {
+    return {
+        body: finding.body,
+        fix: "Please address this before merging.",
+        path: finding.path,
+        reviewer,
+        ...(finding.line == null ? {} : { line: finding.line }),
+        ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
+        type: finding.line == null ? "file" : "inline",
+    };
+}
+export function blockingReviewFindings(outputs) {
+    return Object.entries(outputs).flatMap(([reviewer, output]) => {
+        if (output.verdict !== "CHANGES_REQUESTED")
+            return [];
+        const requirementFindings = output.requirementFindings.map((finding) => ({
+            evidence: finding.evidence,
+            fix: finding.fix,
+            issueNumber: finding.issueNumber,
+            requirement: finding.requirement,
+            reviewer,
+            type: "requirement",
+        }));
+        if ("findings" in output) {
+            return [
+                ...output.findings.map((finding) => ({
+                    fix: finding.fix,
+                    issue: finding.issue,
+                    path: finding.path,
+                    reviewer,
+                    ...(finding.line == null ? {} : { line: finding.line }),
+                    ...(finding.startLine == null
+                        ? {}
+                        : { startLine: finding.startLine }),
+                    type: finding.line == null ? "file" : "inline",
+                })),
+                ...requirementFindings,
+            ];
+        }
+        return [
+            ...output.newFindings.map((finding) => newFindingToEditorFinding(reviewer, finding)),
+            ...requirementFindings,
+        ];
+    });
+}
 async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionIds, ciFailureContext, options = {}) {
     throwIfAborted(input.signal);
     const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
@@ -460,15 +506,42 @@ function syntheticReviewThreads(outputs) {
     const threads = {};
     for (const [reviewer, output] of Object.entries(outputs)) {
         if ("findings" in output) {
-            threads[reviewer] = output.findings.map((finding) => {
+            threads[reviewer] = output.findings.flatMap((finding) => {
+                if (finding.line == null)
+                    return [];
                 const commentId = nextCommentId--;
-                return {
-                    body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                return [
+                    {
+                        body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                        commentId,
+                        comments: [
+                            {
+                                author: reviewer,
+                                body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                                commentId,
+                                createdAt: new Date(0).toISOString(),
+                            },
+                        ],
+                        line: finding.line,
+                        path: finding.path,
+                        threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
+                    },
+                ];
+            });
+            continue;
+        }
+        threads[reviewer] = output.newFindings.flatMap((finding) => {
+            if (finding.line == null)
+                return [];
+            const commentId = nextCommentId--;
+            return [
+                {
+                    body: finding.body,
                     commentId,
                     comments: [
                         {
                             author: reviewer,
-                            body: `Issue: ${finding.issue}\n\nFix: ${finding.fix}`,
+                            body: finding.body,
                             commentId,
                             createdAt: new Date(0).toISOString(),
                         },
@@ -476,27 +549,8 @@ function syntheticReviewThreads(outputs) {
                     line: finding.line,
                     path: finding.path,
                     threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
-                };
-            });
-            continue;
-        }
-        threads[reviewer] = output.newFindings.map((finding) => {
-            const commentId = nextCommentId--;
-            return {
-                body: finding.body,
-                commentId,
-                comments: [
-                    {
-                        author: reviewer,
-                        body: finding.body,
-                        commentId,
-                        createdAt: new Date(0).toISOString(),
-                    },
-                ],
-                line: finding.line,
-                path: finding.path,
-                threadId: `dry-run:${reviewer}:${Math.abs(commentId)}`,
-            };
+                },
+            ];
         });
     }
     return threads;
@@ -666,7 +720,14 @@ export async function runMerge(input) {
                 maxThreadResolutionCycles: input.repository.merge.maxThreadResolutionCycles,
                 threads: unresolvedThreads,
             });
-            if (!editableThreads.length) {
+            const editorFindings = blockingReviewFindings(reportOutputs);
+            const editableFindings = editableThreads.length
+                ? editorFindings
+                : editorFindings.filter((finding) => finding.type !== "inline");
+            const findingAttemptsExhausted = input.repository.merge.maxThreadResolutionCycles !== 0 &&
+                cycle > input.repository.merge.maxThreadResolutionCycles;
+            if (!editableThreads.length &&
+                (!editableFindings.length || findingAttemptsExhausted)) {
                 await input.onProgress?.({
                     status: "changes_unresolved",
                     type: "merge_completed",
@@ -693,7 +754,7 @@ export async function runMerge(input) {
             });
             if (!review.worktreePath)
                 throw new Error("Review worktree is missing");
-            const editorOutput = await runEditor(abortableInput, review.worktreePath, cycle, editableThreads);
+            const editorOutput = await runEditor(abortableInput, review.worktreePath, cycle, editableFindings, editableThreads);
             editorOutputs.push(editorOutput);
             dryRunThreads = input.dryRun
                 ? appendDryRunEditorResponses({

package/dist/orchestrator/report.js

@@ -16,15 +16,19 @@ function pullRequestLine(input) {
     return `- **Pull Request**: [#${input.pr}](${url})`;
 }
 function formatFinding(finding) {
-    const line = finding.startLine == null
-        ? `${finding.path}:${finding.line}`
-        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.line == null
+        ? finding.path
+        : finding.startLine == null
+            ? `${finding.path}:${finding.line}`
+            : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.issue}`;
 }
 function formatRereviewFinding(finding) {
-    const line = finding.startLine == null
-        ? `${finding.path}:${finding.line}`
-        : `${finding.path}:${finding.startLine}-${finding.line}`;
+    const line = finding.line == null
+        ? finding.path
+        : finding.startLine == null
+            ? `${finding.path}:${finding.line}`
+            : `${finding.path}:${finding.startLine}-${finding.line}`;
     return `\`${line}\`: ${finding.body}`;
 }
 function formatRequirementFinding(finding) {

package/dist/orchestrator/review.js

@@ -135,8 +135,69 @@ function parseRereviewOutputWithInlineTargets(text, targets) {
     validateInlineCommentTargets(output.newFindings, targets, "newFindings");
     return output;
 }
-function reviewOutputFromState(review) {
+function parsePostedFindingLocation(location) {
+    const range = /^(.*):(\d+)-(\d+)$/.exec(location);
+    if (range) {
+        return {
+            line: Number(range[3]),
+            path: range[1] ?? location,
+            startLine: Number(range[2]),
+        };
+    }
+    const line = /^(.*):(\d+)$/.exec(location);
+    if (line)
+        return { line: Number(line[2]), path: line[1] ?? location };
+    return { path: location };
+}
+function reviewFindingsFromBody(body) {
+    const findings = [];
+    const requirementFindings = [];
+    const lines = (body ?? "").split(/\r?\n/);
+    let section;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (line === "Inline findings:" || line === "File-level findings:") {
+            section = "finding";
+            continue;
+        }
+        if (line === "Requirement findings:") {
+            section = "requirement";
+            continue;
+        }
+        if (section === "finding") {
+            const match = /^- (.*): (.+)$/.exec(line ?? "");
+            const fix = /^\s+Fix: (.+)$/.exec(lines[index + 1] ?? "");
+            if (!match || !fix)
+                continue;
+            findings.push({
+                ...parsePostedFindingLocation(match[1] ?? ""),
+                fix: fix[1] ?? "Please address this before merging.",
+                issue: match[2] ?? "Review finding.",
+            });
+            index += 1;
+            continue;
+        }
+        if (section !== "requirement")
+            continue;
+        const match = /^- Missing issue #(\d+) requirement: (.+)$/.exec(line ?? "");
+        const evidence = /^\s+Evidence: (.+)$/.exec(lines[index + 1] ?? "");
+        const fix = /^\s+Fix: (.+)$/.exec(lines[index + 2] ?? "");
+        if (!match || !evidence || !fix)
+            continue;
+        requirementFindings.push({
+            evidence: evidence[1] ?? "See review body.",
+            fix: fix[1] ?? "Please address this before merging.",
+            issueNumber: Number(match[1]),
+            requirement: match[2] ?? "Review requirement.",
+        });
+        index += 2;
+    }
+    return { findings, requirementFindings };
+}
+export function reviewOutputFromState(review) {
     const verdict = reviewStateToVerdict(review.state);
+    if (verdict === "CHANGES_REQUESTED")
+        return { ...reviewFindingsFromBody(review.body), verdict };
     return verdict === "CLOSE"
         ? {
             findings: [],
@@ -173,8 +234,8 @@ async function postRereviewOutput(input, reviewerKey, output) {
     return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
         fix: "Please address this before merging.",
         issue: finding.body,
-        line: finding.line,
         path: finding.path,
+        ...(finding.line == null ? {} : { line: finding.line }),
         startLine: finding.startLine,
     })), output.requirementFindings);
 }
@@ -761,7 +822,14 @@ export async function runReview(input) {
             sessionIds,
             worktreePath,
         });
-        const outputs = validation.outputs;
+        const activeOutputs = validation.outputs;
+        const skippedOutputs = Object.fromEntries(input.repository.agents.reviewers.flatMap((reviewer) => {
+            const assignment = mode.assignments.get(reviewer.account);
+            return assignment?.type === "skip"
+                ? [[reviewer.key, reviewOutputFromState(assignment.review)]]
+                : [];
+        }));
+        const outputs = { ...skippedOutputs, ...activeOutputs };
         const remainingSkippedVerdicts = input.repository.agents.reviewers.flatMap((reviewer) => {
             const assignment = mode.assignments.get(reviewer.account);
             if (assignment?.type !== "skip" || closeTargets.includes(reviewer.key))
@@ -773,7 +841,7 @@ export async function runReview(input) {
                 },
             ];
         });
-        const activeVerdicts = Object.entries(outputs).map(([reviewer, output]) => ({
+        const activeVerdicts = Object.entries(activeOutputs).map(([reviewer, output]) => ({
             reviewer,
             verdict: output.verdict,
         }));
@@ -786,7 +854,7 @@ export async function runReview(input) {
                     ? [[reviewer.key, "skipped: already reviewed current head"]]
                     : [];
             })),
-            ...Object.fromEntries(await Promise.all(Object.entries(outputs).map(async ([key, output]) => [
+            ...Object.fromEntries(await Promise.all(Object.entries(activeOutputs).map(async ([key, output]) => [
                 key,
                 input.dryRun
                     ? dryRunReviewPost(key, output)

package/dist/prompts/compose.js

@@ -62,6 +62,7 @@ function editValues(input) {
     return {
         ...repositoryValues(input.repository),
         pr: String(input.pr),
+        reviewFindings: input.reviewFindings,
         unresolvedThreads: input.unresolvedThreads,
         worktreePath: input.worktreePath,
     };

package/dist/prompts/contracts.js

@@ -31,9 +31,10 @@ Rules:
 - CHANGES_REQUESTED requires at least one finding or requirementFinding.
 - CLOSE requires a reason and empty findings and requirementFindings arrays.
 - path must be repository-relative.
-- line and startLine must refer to lines inside the PR diff hunk.
-- Omit startLine for single-line findings.
-- Use requirementFindings for missing closing-issue requirements that do not map cleanly to a diff line.
+- line is optional. Include line only when the finding targets a valid line inside the PR diff hunk.
+- startLine is allowed only when line is present and must also refer to a line inside the PR diff hunk.
+- Omit startLine for single-line findings and omit line for file-level or body-only findings.
+- Use requirementFindings only for missing closing-issue requirements; use findings for ordinary file-level issues that do not map cleanly to a diff line.
 </output_contract>`.trim();
 export const rereviewOutputContract = `
 <output_contract>
@@ -53,9 +54,10 @@ Rules:
 - MERGE requires empty followUps, newFindings, and requirementFindings arrays.
 - CHANGES_REQUESTED requires at least one followUp, newFinding, or requirementFinding.
 - CLOSE requires a reason and empty followUps, newFindings, and requirementFindings arrays.
-- line and startLine must refer to lines inside the latest PR diff hunk.
-- Omit startLine for single-line findings.
-- Use requirementFindings for missing closing-issue requirements that do not map cleanly to a diff line.
+- line is optional. Include line only when the newFinding targets a valid line inside the latest PR diff hunk.
+- startLine is allowed only when line is present and must also refer to a line inside the latest PR diff hunk.
+- Omit startLine for single-line findings and omit line for file-level or body-only findings.
+- Use requirementFindings only for missing closing-issue requirements; use newFindings for ordinary file-level issues that do not map cleanly to a diff line.
 </output_contract>`.trim();
 export const findingValidationOutputContract = `
 <output_contract>
@@ -102,7 +104,9 @@ Rules:
 - MERGE requires empty findings and requirementFindings arrays.
 - CHANGES_REQUESTED requires at least one finding or requirementFinding.
 - CLOSE is not allowed in this reconsideration step.
-- Omit startLine for single-line findings.
+- line is optional. Include line only when the finding targets a valid line inside the PR diff hunk.
+- startLine is allowed only when line is present.
+- Omit startLine for single-line findings and omit line for file-level or body-only findings.
 </output_contract>`.trim();
 export const rereviewCloseReconsiderationOutputContract = `
 <output_contract>
@@ -121,7 +125,9 @@ Rules:
 - MERGE requires empty followUps, newFindings, and requirementFindings arrays.
 - CHANGES_REQUESTED requires at least one followUp, newFinding, or requirementFinding.
 - CLOSE is not allowed in this reconsideration step.
-- Omit startLine for single-line findings.
+- line is optional. Include line only when the newFinding targets a valid line inside the latest PR diff hunk.
+- startLine is allowed only when line is present.
+- Omit startLine for single-line findings and omit line for file-level or body-only findings.
 </output_contract>`.trim();
 export const editOutputContract = `
 <output_contract>

package/dist/prompts/output.js

@@ -71,6 +71,16 @@ function requireNumber(value, path) {
         throw new Error(`${path} must be an integer`);
     return value;
 }
+function optionalLine(value, path) {
+    return value == null ? undefined : requireNumber(value, path);
+}
+function optionalStartLine(input) {
+    if (input.value == null)
+        return undefined;
+    if (input.line == null)
+        throw new Error(`${input.path} requires line`);
+    return requireNumber(input.value, input.path);
+}
 function parseRequirementFindings(value) {
     return (value == null ? [] : requireArray(value, "requirementFindings")).map((finding, index) => {
         const item = finding;
@@ -173,17 +183,20 @@ export function parseReviewOutput(text) {
         throw new Error("verdict must be MERGE, CHANGES_REQUESTED, or CLOSE");
     const findings = requireArray(data.findings, "findings").map((finding, index) => {
         const item = finding;
+        const line = optionalLine(item.line, `findings[${index}].line`);
         return {
             fix: requireString(item.fix, `findings[${index}].fix`),
             issue: requireString(item.issue, `findings[${index}].issue`),
-            line: requireNumber(item.line, `findings[${index}].line`),
+            line,
             path: requireString(item.path, `findings[${index}].path`),
             perspective: item.perspective == null
                 ? undefined
                 : requireString(item.perspective, `findings[${index}].perspective`),
-            startLine: item.startLine == null
-                ? undefined
-                : requireNumber(item.startLine, `findings[${index}].startLine`),
+            startLine: optionalStartLine({
+                line,
+                path: `findings[${index}].startLine`,
+                value: item.startLine,
+            }),
         };
     });
     const requirementFindings = parseRequirementFindings(data.requirementFindings);
@@ -229,13 +242,16 @@ export function parseRereviewOutput(text) {
     });
     const newFindings = requireArray(data.newFindings, "newFindings").map((item, index) => {
         const value = item;
+        const line = optionalLine(value.line, `newFindings[${index}].line`);
         return {
             body: requireString(value.body, `newFindings[${index}].body`),
-            line: requireNumber(value.line, `newFindings[${index}].line`),
+            line,
             path: requireString(value.path, `newFindings[${index}].path`),
-            startLine: value.startLine == null
-                ? undefined
-                : requireNumber(value.startLine, `newFindings[${index}].startLine`),
+            startLine: optionalStartLine({
+                line,
+                path: `newFindings[${index}].startLine`,
+                value: value.startLine,
+            }),
         };
     });
     const requirementFindings = parseRequirementFindings(data.requirementFindings);
@@ -349,7 +365,7 @@ function parseEditOutputWithOptions(text, options) {
             commentId: requireNumber(value.commentId, `responses[${index}].commentId`),
         };
     });
-    if (options.requireResponses && !responses.length)
+    if (options.requireResponses && data.mode === "REPLIED" && !responses.length)
         throw new Error("responses must not be empty");
     if (data.mode === "EDITED") {
         if (!filesTouched.length)

package/dist/prompts/templates/merge/edit.md

@@ -1,9 +1,16 @@
 Fix pull request #{pr} for {owner}/{repo}.
 The PR worktree is {worktreePath}.
-Act as the PR author and resolve every unresolved review thread listed below.
+
+Act as the PR author and address every blocking review finding listed below.
+Review findings are the complete set of requested changes. Inline findings target a PR diff line; file-level findings may not have a GitHub thread; requirement findings describe missing closing-issue requirements.
+{reviewFindings}
+
+Unresolved GitHub review threads are conversations that may need replies or resolution.
 {unresolvedThreads}
-For each thread, decide whether you agree with the reviewer.
-If you understand and agree with the requested change, edit the code, stage changes, commit, and reply with action FIXED.
-If the requested change is incorrect or unnecessary and you have a clear reason, do not edit for that thread; reply with action DISAGREE and explain why.
-If you cannot determine whether the request is correct or what change is expected, do not blindly edit; reply with action ASK and ask a concrete question.
+
+For each review finding and thread, decide whether you agree with the reviewer.
+If you understand and agree with the requested change, edit the code, stage changes, commit, and reply with action FIXED for each related thread.
+If a requested change in a thread is incorrect or unnecessary and you have a clear reason, do not edit for that thread; reply with action DISAGREE and explain why.
+If you cannot determine whether a threaded request is correct or what change is expected, do not blindly edit; reply with action ASK and ask a concrete question.
+File-level and requirement findings may not have a thread to reply to, but they are still blocking and must be addressed.
 Do not make changes just because a reviewer requested them. Do not push.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-magi",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Multi-agent PR review and merge orchestration plugin for OpenCode.",
   "license": "MIT",
   "author": "Hirotomo Yamada <hirotomo.yamada@avap.co.jp>",

package/schema.json

@@ -9,7 +9,11 @@
       "type": "object",
       "additionalProperties": false,
       "properties": {
-        "permissions": { "$ref": "#/$defs/permissions" }
+        "permissions": { "$ref": "#/$defs/permissions" },
+        "refs": {
+          "type": "object",
+          "additionalProperties": { "$ref": "#/$defs/agentRef" }
+        }
       }
     },
     "clear": {
@@ -51,11 +55,33 @@
     "triage": { "$ref": "#/$defs/triage" }
   },
   "$defs": {
+    "agentRef": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]+$" },
+        "model": { "type": "string", "minLength": 1 },
+        "options": { "type": "object", "additionalProperties": true },
+        "account": { "type": "string", "minLength": 1 },
+        "author": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "name": { "type": "string", "minLength": 1 },
+            "email": { "type": "string", "minLength": 1 }
+          }
+        },
+        "permissions": { "$ref": "#/$defs/permissions" },
+        "persona": { "type": "string" }
+      }
+    },
     "reviewer": {
       "type": "object",
-      "required": ["model", "account"],
+      "if": { "not": { "required": ["ref"] } },
+      "then": { "required": ["model", "account"] },
       "additionalProperties": false,
       "properties": {
+        "ref": { "type": "string", "minLength": 1 },
         "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]+$" },
         "model": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },
@@ -66,9 +92,11 @@
     },
     "editor": {
       "type": "object",
-      "required": ["model", "account", "author"],
+      "if": { "not": { "required": ["ref"] } },
+      "then": { "required": ["model", "account", "author"] },
       "additionalProperties": false,
       "properties": {
+        "ref": { "type": "string", "minLength": 1 },
         "model": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },
         "account": { "type": "string", "minLength": 1 },
@@ -87,9 +115,11 @@
     },
     "triageAgent": {
       "type": "object",
-      "required": ["model"],
+      "if": { "not": { "required": ["ref"] } },
+      "then": { "required": ["model"] },
       "additionalProperties": false,
       "properties": {
+        "ref": { "type": "string", "minLength": 1 },
         "id": { "type": "string", "pattern": "^[A-Za-z0-9_-]+$" },
         "model": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },
@@ -99,9 +129,11 @@
     },
     "triageCreator": {
       "type": "object",
-      "required": ["model", "author"],
+      "if": { "not": { "required": ["ref"] } },
+      "then": { "required": ["model", "author"] },
       "additionalProperties": false,
       "properties": {
+        "ref": { "type": "string", "minLength": 1 },
         "account": { "type": "string", "minLength": 1 },
         "model": { "type": "string", "minLength": 1 },
         "options": { "type": "object", "additionalProperties": true },