opencode-magi 0.5.0 → 0.6.1

package/dist/orchestrator/ci.js

@@ -176,7 +176,15 @@ function ciFailureContextForClassified(items, classified) {
         return "";
     return [
         "CI has scope-in failures that may be caused by this PR.",
-        "Use this as a review hint; still inspect the PR diff before reporting findings.",
+        "Treat these failures as blocking review issues until the checks pass.",
+        [
+            "Do not approve this PR while this ci_failure_context is present.",
+            "Return CHANGES_REQUESTED and include a finding for each failing CI check.",
+        ].join(" "),
+        [
+            "Still inspect the PR diff before reporting findings.",
+            "If a CI failure does not map to an exact changed line, anchor the finding to the nearest responsible or first relevant changed line.",
+        ].join(" "),
         "",
         ...sections,
     ].join("\n\n");
@@ -221,7 +229,7 @@ async function watchRerunRuns(exec, repository, checks) {
     await Promise.all(runIds.map((runId) => watchRun(exec, repository, runId)));
 }
 async function checksForHead(input) {
-    const checks = await fetchPullRequestChecks(input.exec, input.repository, input.pr, { tolerateMissingChecks: Boolean(input.headSha) });
+    const checks = await fetchPullRequestChecks(input.exec, input.repository, input.pr, { requiredOnly: true, tolerateMissingChecks: Boolean(input.headSha) });
     const targetChecks = [];
     let hasAnyActionCheck = false;
     let hasTargetActionCheck = false;
@@ -246,7 +254,6 @@ async function checksForHead(input) {
     return {
         blocking: targetChecks.filter((check) => isFailedCheck(check) || isCancelledCheck(check)),
         hasAnyActionCheck,
-        hasAnyCheck: checks.length > 0,
         hasPending: targetChecks.some(isPendingCheck),
         hasTargetActionCheck,
     };
@@ -343,6 +350,7 @@ async function classifyChecks(input) {
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.parentSessionId,
                 parse: (text) => {
                     const output = parseCiClassificationOutput(text);
                     for (const check of output.checks) {
@@ -366,18 +374,20 @@ async function classifyChecks(input) {
             const rawPath = input.outputDir
                 ? join(input.outputDir, `${reviewer.key}.ci-classification.raw.txt`)
                 : undefined;
-            const check = result.value.checks[0];
+            const checks = result.value.checks.map((check) => ({
+                classification: check.classification,
+                name: check.name,
+                reason: check.reason,
+            }));
             if (rawPath)
                 await writeFile(rawPath, result.raw);
-            run.classification = check?.classification;
+            run.checks = checks;
             run.rawPath = rawPath;
-            run.reason = check?.reason;
             run.sessionId = result.sessionId;
             run.status = "completed";
             await input.onClassifierProgress?.({
-                classification: check?.classification ?? "SCOPE_IN",
+                checks,
                 rawPath,
-                reason: check?.reason ?? "No classification reason was provided.",
                 reviewer: reviewer.key,
                 sessionId: result.sessionId,
                 type: "classifier_completed",
@@ -392,22 +402,20 @@ async function classifyChecks(input) {
                 reviewer: reviewer.key,
                 type: "classifier_failed",
             });
-            return { reviewer: reviewer.key, output: undefined };
+            throw error;
         }
     }, { signal: input.signal });
     const threshold = majorityThreshold(reviewers.length);
     return {
         classified: input.checks.map((item) => {
-            const successfulVotes = votes.filter((vote) => vote.output);
-            const checkVotes = successfulVotes.map((vote) => {
-                const check = vote.output?.checks.find((output) => output.name === item.check.name);
+            const checkVotes = votes.map((vote) => {
+                const check = vote.output.checks.find((output) => output.name === item.check.name);
                 return {
                     classification: check?.classification ?? "SCOPE_IN",
                     reason: check?.reason ?? "Missing classification; treated as scope-in.",
                     reviewer: vote.reviewer,
                 };
             });
-            const failures = votes.filter((vote) => !vote.output);
             const scopeIn = checkVotes.filter((vote) => vote.classification === "SCOPE_IN");
             const scopeOut = checkVotes.filter((vote) => vote.classification === "SCOPE_OUT");
             const classification = scopeOut.length >= threshold
@@ -421,9 +429,6 @@ async function classifyChecks(input) {
             const reasons = checkVotes
                 .filter((vote) => vote.classification === classification)
                 .map((vote) => `${vote.reviewer}: ${vote.reason}`);
-            for (const failure of failures) {
-                reasons.push(`${failure.reviewer}: classifier failed; vote ignored`);
-            }
             return {
                 check: item.check,
                 classification,
@@ -457,15 +462,17 @@ export async function waitForChecksWithClassification(input) {
         await input.onProgress?.("waiting for CI checks");
         for (let attempt = 0;; attempt += 1) {
             try {
-                await watchChecks(input.exec, input.repository, input.pr);
+                await watchChecks(input.exec, input.repository, input.pr, {
+                    requiredOnly: true,
+                });
             }
             catch {
                 // gh exits non-zero for pending checks too; re-read check state below.
             }
             const target = await readTargetChecks();
             const waitingForTargetHead = Boolean(input.headSha) &&
-                (!target.hasAnyCheck ||
-                    (target.hasAnyActionCheck && !target.hasTargetActionCheck));
+                target.hasAnyActionCheck &&
+                !target.hasTargetActionCheck;
             if (!waitingForTargetHead && !target.hasPending) {
                 await assignBlockingChecks(target.blocking);
                 break;
@@ -505,6 +512,7 @@ export async function waitForChecksWithClassification(input) {
                 directory: input.directory,
                 onClassifierProgress: input.onClassifierProgress,
                 outputDir: input.outputDir,
+                parentSessionId: input.parentSessionId,
                 pr: input.pr,
                 repairAttempts: input.repairAttempts,
                 repository: input.repository,
@@ -545,8 +553,11 @@ export async function waitForChecksWithClassification(input) {
         try {
             await input.onProgress?.("waiting for rerun CI checks");
             await watchRerunRuns(input.exec, input.repository, rerunnable);
-            if (input.wait)
-                await watchChecks(input.exec, input.repository, input.pr);
+            if (input.wait) {
+                await watchChecks(input.exec, input.repository, input.pr, {
+                    requiredOnly: true,
+                });
+            }
         }
         catch {
             // Re-read the PR checks below so stale failed checks are not trusted.

package/dist/orchestrator/findings.js

@@ -1,9 +1,20 @@
 import { majorityThreshold } from "./majority";
+function validationFindings(output) {
+    if ("findings" in output)
+        return output.findings;
+    return output.newFindings.map((finding) => ({
+        fix: "Please address this before merging.",
+        issue: finding.body,
+        line: finding.line,
+        path: finding.path,
+        startLine: finding.startLine,
+    }));
+}
 export function reviewFindingTargets(outputs) {
     return Object.entries(outputs).flatMap(([reviewer, output]) => {
         if (output.verdict !== "CHANGES_REQUESTED")
             return [];
-        return output.findings.map((finding, findingIndex) => ({
+        return validationFindings(output).map((finding, findingIndex) => ({
             finding,
             findingIndex,
             reviewer,
@@ -41,7 +52,9 @@ export function applyFindingValidation(input) {
             next[reviewer] = output;
             continue;
         }
-        const findings = output.findings.filter((finding, findingIndex) => {
+        const keptIndexes = new Set();
+        const findings = validationFindings(output);
+        findings.forEach((finding, findingIndex) => {
             let agrees = 1;
             for (const validator of input.reviewerKeys) {
                 if (validator === reviewer)
@@ -53,14 +66,23 @@ export function applyFindingValidation(input) {
             const target = { finding, findingIndex, reviewer };
             if (agrees >= threshold) {
                 kept.push(target);
-                return true;
+                keptIndexes.add(findingIndex);
+                return;
             }
             discarded.push(target);
-            return false;
         });
-        next[reviewer] = findings.length
-            ? { ...output, findings }
-            : { findings: [], verdict: "MERGE" };
+        if ("findings" in output) {
+            const keptFindings = output.findings.filter((_finding, index) => keptIndexes.has(index));
+            next[reviewer] = keptFindings.length
+                ? { ...output, findings: keptFindings }
+                : { findings: [], verdict: "MERGE" };
+            continue;
+        }
+        const newFindings = output.newFindings.filter((_finding, index) => keptIndexes.has(index));
+        next[reviewer] =
+            newFindings.length || output.followUps.length
+                ? { ...output, newFindings }
+                : { ...output, newFindings, verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/majority.js

@@ -10,7 +10,7 @@ export function aggregateStringMajority(results, votes) {
     const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
     for (const result of results) {
         counts[result.vote] += 1;
-        voters[result.vote].push(result.reviewer);
+        voters[result.vote].push(result.voter);
     }
     const threshold = majorityThreshold(results.length);
     const vote = votes.find((item) => counts[item] >= threshold);

package/dist/orchestrator/merge.js

@@ -1,17 +1,17 @@
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { prRunOutputDir } from "../config/output";
-import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, shellQuote, waitForMergeQueue, } from "../github/commands";
+import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, waitForAutoMerge, waitForMergeQueue, } from "../github/commands";
 import { composeEditPrompt, composeRereviewCloseReconsiderationPrompt, composeRereviewPrompt, } from "../prompts/compose";
 import { parseEditOutput, parseRereviewCloseReconsiderationOutput, parseRereviewOutput, } from "../prompts/output";
 import { throwIfAborted, withAbortSignal } from "./abort";
 import { waitForChecksWithClassification } from "./ci";
-import { parseRightSideDiffTargets, validateInlineCommentTargets, } from "./inline-comments";
+import { validateInlineCommentTargets, } from "./inline-comments";
 import { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
 import { formatMergeReport } from "./report";
-import { runReview } from "./review";
+import { inlineCommentTargetsForDiff, runReview, } from "./review";
 import { checkSafetyGate, hasSafetyGate } from "./safety";
 function outputDir(input) {
     return prRunOutputDir({
@@ -53,7 +53,7 @@ async function withReviewerFailureProgress(input) {
 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");
+        throw new Error("merge.editor is required for magi_merge");
     throwIfAborted(input.signal);
     await configureGitIdentity(input.exec, worktreePath, {
         email: editor.author?.email,
@@ -96,6 +96,7 @@ async function runEditor(input, worktreePath, cycle, reviewFindings, unresolvedT
                 }
             },
             options: editor.options,
+            parentSessionId: input.parentSessionId,
             parse: parseEditOutput,
             permission: editor.permission,
             prompt,
@@ -195,7 +196,21 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
     throwIfAborted(input.signal);
     const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
     const headSha = options.dryRunHeadSha ?? meta.headRefOid;
-    const inlineCommentTargets = parseRightSideDiffTargets(await input.exec(`git diff --no-ext-diff --unified=3 ${shellQuote(meta.baseRefOid)} ${shellQuote(headSha)}`, { cwd: worktreePath }));
+    const inlineCommentTargets = await inlineCommentTargetsForDiff({
+        ensure: options.dryRunHeadSha
+            ? undefined
+            : {
+                fromSource: "base",
+                meta,
+                repository: input.repository,
+                toSource: "head",
+            },
+        exec: input.exec,
+        fromSha: meta.baseRefOid,
+        range: "direct",
+        toSha: headSha,
+        worktreePath,
+    });
     const artifactDir = outputDir(input);
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
@@ -250,6 +265,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                     }
                 },
                 options: reviewer.options,
+                parentSessionId: input.parentSessionId,
                 parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                 permission: reviewer.permission,
                 prompt,
@@ -294,7 +310,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                 baseSha: meta.baseRefOid,
                 closeReason: entry.output.reason,
                 directory: input.directory,
-                headSha: meta.headRefOid,
+                headSha,
                 includeReviewGuidelines: !hasReviewerSession,
                 includeSessionContext: !hasReviewerSession,
                 pr: input.pr,
@@ -333,6 +349,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                         }
                     },
                     options: reviewer.options,
+                    parentSessionId: input.parentSessionId,
                     parse: (text) => {
                         const output = parseRereviewCloseReconsiderationOutput(text);
                         validateInlineCommentTargets(output.newFindings, inlineCommentTargets, "newFindings");
@@ -409,8 +426,11 @@ async function finishMergeRun(input, result, reportInput) {
 }
 async function mergeWithQueue(input, exec, editorAccount) {
     await mergePullRequest(exec, input.repository, input.pr, editorAccount);
-    if (!input.repository.merge.mergeQueue)
-        return "merged";
+    if (!input.repository.merge.mergeQueue) {
+        if (!input.repository.merge.auto)
+            return "merged";
+        return waitForAutoMerge(exec, input.repository, input.pr);
+    }
     return waitForMergeQueue(exec, input.repository, input.pr);
 }
 export function hasBlockingCiReports(reports) {
@@ -570,7 +590,7 @@ export async function runMerge(input) {
     const abortableInput = { ...input, exec };
     const editor = input.repository.agents.editor;
     if (!editor)
-        throw new Error("agents.editor is required for magi_merge");
+        throw new Error("merge.editor is required for magi_merge");
     throwIfAborted(input.signal);
     const artifactDir = outputDir(input);
     await mkdir(artifactDir, { recursive: true });
@@ -701,7 +721,7 @@ export async function runMerge(input) {
                 threads: unresolvedThreads,
             });
             const editorFindings = blockingReviewFindings(reportOutputs);
-            const editableFindings = editableThreads.length ? editorFindings : [];
+            const editableFindings = editorFindings;
             const findingAttemptsExhausted = input.repository.merge.maxThreadResolutionCycles !== 0 &&
                 cycle > input.repository.merge.maxThreadResolutionCycles;
             if (!editableThreads.length &&
@@ -781,6 +801,7 @@ export async function runMerge(input) {
                         exec,
                         headSha: editedHeadSha,
                         onProgress: (phase) => input.onProgress?.({ phase, type: "phase" }),
+                        parentSessionId: input.parentSessionId,
                         pr: input.pr,
                         repairAttempts: input.config.output?.repairAttempts ?? 3,
                         repository: input.repository,

package/dist/orchestrator/model.js

@@ -89,6 +89,7 @@ function extractText(result, allowEmpty = false) {
 export async function createModelSession(input) {
     return extractSessionId(await input.client.session.create({
         body: {
+            parentID: input.parentSessionId,
             permission: toOpenCodePermissionRules(input.permission),
             title: input.title,
         },
@@ -96,15 +97,26 @@ export async function createModelSession(input) {
 }
 export async function promptModelText(input) {
     throwIfAborted(input.signal);
-    const result = await input.client.session.prompt({
-        body: {
-            model: modelBody(input.model),
-            parts: [{ type: "text", text: input.prompt }],
-        },
-        path: { id: input.sessionId },
-    });
-    throwIfAborted(input.signal);
-    return extractText(result, input.allowEmpty);
+    const abort = () => {
+        void input.client.session
+            .abort?.({ path: { id: input.sessionId } })
+            .catch(() => undefined);
+    };
+    input.signal?.addEventListener("abort", abort, { once: true });
+    try {
+        const result = await input.client.session.prompt({
+            body: {
+                model: modelBody(input.model),
+                parts: [{ type: "text", text: input.prompt }],
+            },
+            path: { id: input.sessionId },
+        });
+        throwIfAborted(input.signal);
+        return extractText(result, input.allowEmpty);
+    }
+    finally {
+        input.signal?.removeEventListener("abort", abort);
+    }
 }
 async function sendPrompt(client, sessionId, model, prompt, signal) {
     return promptModelText({ client, model, prompt, sessionId, signal });
@@ -113,6 +125,7 @@ export async function runModelText(input) {
     throwIfAborted(input.signal);
     const sessionId = await createModelSession({
         client: input.client,
+        parentSessionId: input.parentSessionId,
         permission: input.permission,
         title: input.title,
     });
@@ -152,6 +165,7 @@ export async function runModelWithRepair(input) {
             ? input.sessionId
             : extractSessionId(await input.client.session.create({
                 body: {
+                    parentID: input.parentSessionId,
                     permission: toOpenCodePermissionRules(input.permission),
                     title: input.title,
                 },