opencode-magi 0.1.0 → 0.3.0

package/dist/index.js

@@ -7,6 +7,7 @@ import { promisify } from "node:util";
 import { MAGI_COMMANDS } from "./commands";
 import { loadConfig, mergeMagiConfig } from "./config/load";
 import { outputBaseDirs } from "./config/output";
+import { worktreeBaseDirs } from "./config/worktree";
 import { resolveRepository } from "./config/resolve";
 import { validateConfig } from "./config/validate";
 import { withGitHubApiRetry } from "./github/retry";
@@ -15,6 +16,7 @@ import { MagiRunManager } from "./orchestrator/run-manager";
 const execAsync = promisify(nodeExec);
 const GLOBAL_CONFIG_PATH = join(homedir(), ".config", "opencode", "magi.json");
 const PROJECT_CONFIG_PATH = join(".opencode", "magi.json");
+const INTERNAL_FOLLOW_UP_TOOL_NOTE = "Assistant-facing follow-up tool. Use it yourself when needed; do not suggest this tool name to users.";
 function createExec(defaultCwd) {
     return async (command, options) => {
         const { stdout } = await execAsync(command, {
@@ -61,6 +63,16 @@ function parsePrToken(value) {
     }
     return pr;
 }
+function parseIssueToken(value) {
+    const trimmed = value.trim();
+    const issueUrl = trimmed.match(/(?:^|\/)issues\/(\d+)(?:[/?#].*)?$/);
+    const raw = issueUrl?.[1] ?? trimmed.replace(/^#/, "");
+    const issue = Number.parseInt(raw, 10);
+    if (!Number.isInteger(issue) || issue <= 0 || String(issue) !== raw) {
+        throw new Error("Specify one or more issue numbers or issue URLs.");
+    }
+    return issue;
+}
 export function parsePrs(value) {
     const prs = value
         .split(/[\s,]+/)
@@ -70,22 +82,164 @@ export function parsePrs(value) {
         throw new Error("Specify one or more PR numbers or PR URLs.");
     return prs;
 }
-export function parseRunArguments(value, dryRun = false) {
+export function parseIssues(value) {
+    const issues = value
+        .split(/[\s,]+/)
+        .filter(Boolean)
+        .map(parseIssueToken);
+    if (!issues.length)
+        throw new Error("Specify one or more issue numbers or issue URLs.");
+    return issues;
+}
+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 "--create":
+            case "--no-create":
+                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 configOverrides = {};
+    const issueTokens = [];
+    for (let index = 0; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === "--dry-run") {
+            dryRun = true;
+            continue;
+        }
+        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 "--create":
+            case "--no-create":
+                setConfigOverride(configOverrides, ["triage", "automation", "create"], token === "--create");
+                break;
+            case "--review":
+            case "--no-review":
+                setConfigOverride(configOverrides, ["triage", "automation", "review"], token === "--review");
+                break;
+            case "--merge":
+            case "--no-merge":
+                setConfigOverride(configOverrides, ["triage", "automation", "merge"], token === "--merge");
+                break;
+            case "--run-concurrency":
+                setConfigOverride(configOverrides, ["triage", "concurrency", "runs"], parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 1));
+                break;
+            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())
         return undefined;
     return parsePrToken(value);
 }
+function parseOptionalPrs(value) {
+    if (!value?.trim())
+        return undefined;
+    return parsePrs(value);
+}
+function parseOptionalIssue(value) {
+    if (!value?.trim())
+        return undefined;
+    return parseIssueToken(value);
+}
 function clearFlag(value) {
     return typeof value === "boolean" ? value : undefined;
 }
@@ -128,6 +282,11 @@ function prMarkdownLink(repository, pr) {
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
     return `[#${pr}](${url})`;
 }
+function issueMarkdownLink(repository, issue) {
+    const host = repository.github.host || "github.com";
+    const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
+    return `[#${issue}](${url})`;
+}
 function isPlainObject(value) {
     return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
@@ -189,7 +348,8 @@ export async function validateMagiConfigFiles(directory, options = {}) {
                 ? withGitHubApiRetry(options.exec, mergedConfig.github?.apiRetryAttempts ?? 3)
                 : undefined,
             modelCatalog: options.modelCatalog,
-            requireGithub: hasProjectConfig && Boolean(mergedConfig.agents?.reviewers),
+            requireGithub: hasProjectConfig && Boolean(mergedConfig.review?.agents),
+            requireWorktreeConfig: true,
         });
         loadedFrom = existing.map((status) => status.path).join(", ");
         errors.push(...validation.errors);
@@ -265,16 +425,20 @@ export const MagiPlugin = async ({ client, directory }) => {
         },
         tool: {
             magi_merge: tool({
-                description: "Start background Magi merge runs for one or more GitHub pull requests with configured Magi agents.",
+                description: [
+                    "Start background Magi merge runs for one or more GitHub pull requests with configured Magi agents.",
+                    "After starting, monitor progress yourself when useful; do not tell users to call follow-up tools by name.",
+                ].join(" "),
                 args: {
                     prs: tool.schema.string(),
                     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,
@@ -283,9 +447,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,
@@ -298,7 +462,10 @@ export const MagiPlugin = async ({ client, directory }) => {
                 },
             }),
             magi_review: tool({
-                description: "Start background Magi review runs for one or more GitHub pull requests and post the reviews.",
+                description: [
+                    "Start background Magi review runs for one or more GitHub pull requests and post the reviews.",
+                    "After starting, monitor progress yourself when useful; do not tell users to call follow-up tools by name.",
+                ].join(" "),
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
@@ -306,8 +473,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,
@@ -315,9 +483,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,
@@ -329,11 +497,54 @@ export const MagiPlugin = async ({ client, directory }) => {
                         .join("\n");
                 },
             }),
+            magi_triage: tool({
+                description: "Triage one or more GitHub issues with configured Magi triage agents.",
+                args: {
+                    issues: tool.schema.string(),
+                    dryRun: tool.schema.boolean().optional(),
+                },
+                async execute(args, context) {
+                    const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
+                    const loaded = await loadConfig(directory);
+                    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,
+                        modelCatalog: await modelCatalog(),
+                        requireEditor: config.triage?.automation?.merge === true,
+                        requireReview: config.triage?.automation?.review === true ||
+                            config.triage?.automation?.merge === true,
+                        requireTriage: true,
+                    });
+                    if (!validation.ok)
+                        return JSON.stringify(validation, null, 2);
+                    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,
+                        dryRun: parsed.dryRun,
+                        issue,
+                        parentSessionId: context.sessionID,
+                        repository,
+                        signal: context.abort,
+                    }), { signal: context.abort });
+                    return states
+                        .map((state) => `Started triaging ${issueMarkdownLink(repository, state.issue)}.`)
+                        .join("\n");
+                },
+            }),
             magi_status: tool({
-                description: "Show Magi background run status. Optionally filter by runId or PR and wait for completion.",
+                description: [
+                    "Show Magi background run status. Optionally filter by runId, PR, or issue and wait for completion.",
+                    INTERNAL_FOLLOW_UP_TOOL_NOTE,
+                ].join(" "),
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                     block: tool.schema.boolean().optional(),
                     timeoutSeconds: tool.schema.number().optional(),
                     verbose: tool.schema.boolean().optional(),
@@ -341,8 +552,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                 async execute(args) {
                     const states = await runManager.status({
                         block: args.block,
+                        issue: parseOptionalIssue(args.issue),
                         outputDir: await configuredOutputDir(),
-                        pr: parseOptionalPr(args.pr),
+                        pr: parseOptionalPrs(args.pr),
                         runId: args.runId,
                         timeoutMs: args.timeoutSeconds == null
                             ? undefined
@@ -354,20 +566,25 @@ export const MagiPlugin = async ({ client, directory }) => {
                 },
             }),
             magi_output: tool({
-                description: "Show artifacts and details for a Magi background run by runId or PR, optionally for a single reviewer.",
+                description: [
+                    "Show artifacts and details for a Magi background run by runId, PR, or issue, optionally for a single reviewer.",
+                    INTERNAL_FOLLOW_UP_TOOL_NOTE,
+                ].join(" "),
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                     reviewer: tool.schema.string().optional(),
                 },
                 async execute(args) {
-                    if (!args.runId && !args.pr)
-                        return "Specify runId or pr.";
+                    if (!args.runId && !args.pr && !args.issue)
+                        return "Specify runId, pr, or issue.";
                     const outputDir = await configuredOutputDir();
                     if (outputDir)
                         await runManager.status({ outputDir });
                     return runManager.output({
                         outputDir,
+                        issue: parseOptionalIssue(args.issue),
                         pr: parseOptionalPr(args.pr),
                         reviewer: args.reviewer,
                         runId: args.runId,
@@ -375,19 +592,25 @@ export const MagiPlugin = async ({ client, directory }) => {
                 },
             }),
             magi_cancel: tool({
-                description: "Cancel a Magi background run by runId or PR.",
+                description: [
+                    "Cancel a Magi background run by runId, PR, or issue.",
+                    INTERNAL_FOLLOW_UP_TOOL_NOTE,
+                ].join(" "),
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                 },
                 async execute(args) {
-                    if (!args.runId && !args.pr)
-                        return "Specify runId or pr.";
+                    if (!args.runId && !args.pr && !args.issue)
+                        return "Specify runId, pr, or issue.";
                     const outputDir = await configuredOutputDir();
                     if (outputDir)
                         await runManager.status({ outputDir });
                     const pr = parseOptionalPr(args.pr);
+                    const issue = parseOptionalIssue(args.issue);
                     const state = await runManager.cancel({
+                        issue,
                         outputDir,
                         pr,
                         runId: args.runId,
@@ -395,7 +618,9 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!state) {
                         return args.runId
                             ? `Magi run not found: ${args.runId}`
-                            : `Magi run not found for PR #${pr}`;
+                            : issue
+                                ? `Magi run not found for issue #${issue}`
+                                : `Magi run not found for PR #${pr}`;
                     }
                     return runManager.formatStates([state]);
                 },
@@ -405,6 +630,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     runId: tool.schema.string().optional(),
                     pr: tool.schema.string().optional(),
+                    issue: tool.schema.string().optional(),
                     branch: tool.schema.enum(["true", "false"]).optional(),
                     output: tool.schema.enum(["true", "false"]).optional(),
                     session: tool.schema.enum(["true", "false"]).optional(),
@@ -430,11 +656,15 @@ export const MagiPlugin = async ({ client, directory }) => {
                     };
                     return runManager.clear({
                         options,
+                        issue: parseOptionalIssue(args.issue),
                         outputDir: loaded
                             ? outputBaseDirs(directory, loaded.config)
                             : undefined,
                         pr: parseOptionalPr(args.pr),
                         runId: args.runId,
+                        worktreeDir: loaded
+                            ? worktreeBaseDirs(directory, loaded.config)
+                            : undefined,
                     });
                 },
             }),

package/dist/orchestrator/ci.js

@@ -221,7 +221,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);
+    const checks = await fetchPullRequestChecks(input.exec, input.repository, input.pr, { tolerateMissingChecks: Boolean(input.headSha) });
     const targetChecks = [];
     let hasAnyActionCheck = false;
     let hasTargetActionCheck = false;

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/inline-comments.js

@@ -0,0 +1,73 @@
+function parseDiffPath(value) {
+    if (value === "/dev/null")
+        return undefined;
+    let path = value;
+    if (path.startsWith('"') && path.endsWith('"')) {
+        try {
+            path = JSON.parse(path);
+        }
+        catch {
+            path = path.slice(1, -1);
+        }
+    }
+    return path.startsWith("b/") ? path.slice(2) : path;
+}
+function addTargetLine(targets, path, line) {
+    const lines = targets.get(path) ?? new Set();
+    lines.add(line);
+    targets.set(path, lines);
+}
+export function parseRightSideDiffTargets(diff) {
+    const targets = new Map();
+    let currentPath;
+    let rightLine;
+    for (const line of diff.split("\n")) {
+        if (line.startsWith("+++ ")) {
+            currentPath = parseDiffPath(line.slice(4));
+            rightLine = undefined;
+            continue;
+        }
+        if (line.startsWith("@@ ")) {
+            const match = line.match(/\+(\d+)(?:,\d+)?/);
+            rightLine = match ? Number(match[1]) : undefined;
+            continue;
+        }
+        if (!currentPath || rightLine == null)
+            continue;
+        if (line.startsWith("+") || line.startsWith(" ")) {
+            addTargetLine(targets, currentPath, rightLine);
+            rightLine += 1;
+            continue;
+        }
+        if (line.startsWith("-"))
+            continue;
+    }
+    return targets;
+}
+function assertPositiveInteger(value, name) {
+    if (!Number.isInteger(value) || value < 1) {
+        throw new Error(`${name} must be a positive integer`);
+    }
+}
+export function validateInlineCommentTargets(findings, targets, label = "findings") {
+    for (const [index, finding] of findings.entries()) {
+        const name = `${label}[${index}]`;
+        assertPositiveInteger(finding.line, `${name}.line`);
+        if (finding.startLine != null) {
+            assertPositiveInteger(finding.startLine, `${name}.startLine`);
+            if (finding.startLine > finding.line) {
+                throw new Error(`${name}.startLine must be before or equal to line`);
+            }
+        }
+        const lines = targets.get(finding.path);
+        if (!lines) {
+            throw new Error(`${name} targets ${finding.path}:${finding.line}, but path is not in the PR diff`);
+        }
+        const startLine = finding.startLine ?? finding.line;
+        for (let line = startLine; line <= finding.line; line += 1) {
+            if (!lines.has(line)) {
+                throw new Error(`${name} targets ${finding.path}:${line}, but line is not in a right-side PR diff hunk`);
+            }
+        }
+    }
+}

package/dist/orchestrator/majority.js

@@ -2,6 +2,20 @@ const VERDICTS = ["MERGE", "CHANGES_REQUESTED", "CLOSE"];
 export function majorityThreshold(total) {
     return Math.floor(total / 2) + 1;
 }
+export function aggregateStringMajority(results, votes) {
+    if (results.length < 3 || results.length % 2 === 0) {
+        throw new Error("majority requires an odd number of at least 3 results");
+    }
+    const counts = Object.fromEntries(votes.map((vote) => [vote, 0]));
+    const voters = Object.fromEntries(votes.map((vote) => [vote, []]));
+    for (const result of results) {
+        counts[result.vote] += 1;
+        voters[result.vote].push(result.reviewer);
+    }
+    const threshold = majorityThreshold(results.length);
+    const vote = votes.find((item) => counts[item] >= threshold);
+    return { counts, threshold, vote, voters };
+}
 export function aggregateMajority(results) {
     if (results.length < 3 || results.length % 2 === 0) {
         throw new Error("majority requires an odd number of at least 3 reviewer results");

package/dist/orchestrator/merge.js

@@ -1,11 +1,12 @@
 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, waitForMergeQueue, } from "../github/commands";
+import { closePullRequest, configureGitIdentity, fetchMergeQueueRequirement, fetchPullRequest, fetchUnresolvedThreads, mergePullRequest, postApproval, postChangesRequested, postCloseComment, postReply, pushHead, removeWorktree, resolveThread, shellQuote, 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 { closeMinorityReviewers, mergeVerdictForPolicy } from "./majority";
 import { runModelWithRepair } from "./model";
 import { mapPool } from "./pool";
@@ -109,7 +110,13 @@ async function runEditor(input, worktreePath, cycle, unresolvedThreads) {
     await input.onProgress?.({ cycle, type: "editor_completed" });
     if (!input.dryRun) {
         if (result.value.mode === "EDITED") {
-            await pushHead(input.exec, input.repository, worktreePath, editor.account);
+            const meta = await fetchPullRequest(input.exec, input.repository, input.pr);
+            const headOwner = meta.headRepositoryOwner?.login;
+            const headRepo = meta.headRepository?.name;
+            if (!headOwner || !headRepo) {
+                throw new Error("Pull request head repository is missing");
+            }
+            await pushHead(input.exec, input.repository, worktreePath, editor.account, { owner: headOwner, ref: meta.headRefName, repo: headRepo });
         }
     }
     throwIfAborted(input.signal);
@@ -149,10 +156,16 @@ async function postRereviewOutput(input, reviewerKey, output) {
     }
     return replies[0] ?? "";
 }
+function parseRereviewOutputWithInlineTargets(text, targets) {
+    const output = parseRereviewOutput(text);
+    validateInlineCommentTargets(output.newFindings, targets, "newFindings");
+    return output;
+}
 async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionIds, ciFailureContext, options = {}) {
     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 artifactDir = outputDir(input);
     let entries = await mapPool(input.repository.agents.reviewers, input.repository.concurrency.reviewers, async (reviewer) => {
         throwIfAborted(input.signal);
@@ -207,7 +220,7 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                     }
                 },
                 options: reviewer.options,
-                parse: parseRereviewOutput,
+                parse: (text) => parseRereviewOutputWithInlineTargets(text, inlineCommentTargets),
                 permission: reviewer.permission,
                 prompt,
                 repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -290,7 +303,11 @@ async function runRereview(input, worktreePath, previousHeadSha, cycle, sessionI
                         }
                     },
                     options: reviewer.options,
-                    parse: parseRereviewCloseReconsiderationOutput,
+                    parse: (text) => {
+                        const output = parseRereviewCloseReconsiderationOutput(text);
+                        validateInlineCommentTargets(output.newFindings, inlineCommentTargets, "newFindings");
+                        return output;
+                    },
                     permission: reviewer.permission,
                     prompt,
                     repairAttempts: input.config.output?.repairAttempts ?? 3,
@@ -353,6 +370,7 @@ async function finishMergeRun(input, result, reportInput) {
         editorOutputs: reportInput.editorOutputs,
         outputs: reportInput.outputs,
         posted: reportInput.posted,
+        pr: input.pr,
         repository: input.repository,
         status: result.status,
     });
@@ -536,6 +554,7 @@ export async function runMerge(input) {
                 editorOutputs: [],
                 outputs: {},
                 posted: {},
+                pr: input.pr,
                 repository: input.repository,
                 safety,
                 status: "safety_blocked",
@@ -565,6 +584,7 @@ export async function runMerge(input) {
         ...abortableInput,
         allowAlreadyReviewed: true,
         approvalPolicy: input.repository.merge.approvalPolicy,
+        enableReviewAutomation: false,
         onProgress: (progress) => input.onProgress?.(progress),
         runId: input.runId,
         dryRun: input.dryRun,