opencode-magi 0.4.0 → 0.6.0

package/dist/index.js

@@ -95,16 +95,27 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const prTokens = [];
+    let sync = false;
+    let timeoutMs;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
                 break;
+            case "--timeout":
+                timeoutMs =
+                    parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0) *
+                        1_000;
+                break;
             case "--merge":
             case "--no-merge":
                 setConfigOverride(configOverrides, [command, "automation", "merge"], token === "--merge");
@@ -146,22 +157,39 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
                 prTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")) };
+    return {
+        configOverrides,
+        dryRun,
+        prs: parsePrs(prTokens.join(" ")),
+        sync,
+        timeoutMs,
+    };
 }
 export function parseIssueRunArguments(value, dryRun = false) {
     const tokens = value.split(/[\s,]+/).filter(Boolean);
     const configOverrides = {};
     const issueTokens = [];
+    let sync = false;
+    let timeoutMs;
     for (let index = 0; index < tokens.length; index++) {
         const token = tokens[index];
         if (token === "--dry-run") {
             dryRun = true;
             continue;
         }
+        if (token === "--sync") {
+            sync = true;
+            continue;
+        }
         switch (token) {
             case "--language":
                 setConfigOverride(configOverrides, ["language"], nextFlagValue(tokens, ++index, token));
                 break;
+            case "--timeout":
+                timeoutMs =
+                    parseIntegerFlag(nextFlagValue(tokens, ++index, token), token, 0) *
+                        1_000;
+                break;
             case "--close":
             case "--no-close":
                 setConfigOverride(configOverrides, ["triage", "automation", "close"], token === "--close");
@@ -195,7 +223,13 @@ export function parseIssueRunArguments(value, dryRun = false) {
                 issueTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, issues: parseIssues(issueTokens.join(" ")) };
+    return {
+        configOverrides,
+        dryRun,
+        issues: parseIssues(issueTokens.join(" ")),
+        sync,
+        timeoutMs,
+    };
 }
 function nextFlagValue(tokens, index, flag) {
     const value = tokens[index];
@@ -203,6 +237,15 @@ function nextFlagValue(tokens, index, flag) {
         throw new Error(`${flag} requires a value.`);
     return value;
 }
+async function syncResult(runManager, states) {
+    const output = await runManager.formatStatesWithReports(states, {
+        verbose: true,
+    });
+    const failed = states.filter((state) => state.status !== "completed");
+    if (failed.length)
+        throw new Error(output);
+    return output;
+}
 function parseIntegerFlag(value, flag, minimum) {
     const parsed = Number.parseInt(value, 10);
     if (!Number.isInteger(parsed) ||
@@ -282,6 +325,10 @@ function prMarkdownLink(repository, pr) {
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/pull/${pr}`;
     return `[#${pr}](${url})`;
 }
+export function formatRunStartMessage(command, repository, pr) {
+    const action = command === "merge" ? "merge flow" : "reviewing";
+    return `Started ${action} ${prMarkdownLink(repository, pr)}.`;
+}
 function issueMarkdownLink(repository, issue) {
     const host = repository.github.host || "github.com";
     const url = `https://${host}/${repository.github.owner}/${repository.github.repo}/issues/${issue}`;
@@ -432,6 +479,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false, "merge");
@@ -448,6 +496,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startMerge({
                         config,
                         dryRun: parsed.dryRun,
@@ -455,9 +504,13 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
-                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .map((state) => formatRunStartMessage("merge", repository, state.pr))
                         .join("\n");
                 },
             }),
@@ -469,6 +522,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     prs: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseRunArguments(args.prs, args.dryRun ?? false);
@@ -484,6 +538,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     if (!validation.ok)
                         return JSON.stringify(validation, null, 2);
                     const repository = resolveRepository(config);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.prs, repository.concurrency.runs, (pr) => runManager.startReview({
                         config,
                         dryRun: parsed.dryRun,
@@ -491,9 +546,13 @@ export const MagiPlugin = async ({ client, directory }) => {
                         pr,
                         parentSessionId: context.sessionID,
                         signal: context.abort,
+                        sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
-                        .map((state) => `Started reviewing ${prMarkdownLink(repository, state.pr)}.`)
+                        .map((state) => formatRunStartMessage("review", repository, state.pr))
                         .join("\n");
                 },
             }),
@@ -502,6 +561,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                 args: {
                     issues: tool.schema.string(),
                     dryRun: tool.schema.boolean().optional(),
+                    sync: tool.schema.boolean().optional(),
                 },
                 async execute(args, context) {
                     const parsed = parseIssueRunArguments(args.issues, args.dryRun ?? false);
@@ -523,6 +583,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                     const repository = resolveRepository(config);
                     if (!repository.triage)
                         return JSON.stringify({ errors: ["triage configuration is required"], ok: false }, null, 2);
+                    const sync = parsed.sync || args.sync === true;
                     const states = await mapPool(parsed.issues, repository.triage.concurrency.runs, (issue) => runManager.startTriage({
                         config,
                         dryRun: parsed.dryRun,
@@ -530,7 +591,11 @@ export const MagiPlugin = async ({ client, directory }) => {
                         parentSessionId: context.sessionID,
                         repository,
                         signal: context.abort,
+                        sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
+                    if (sync)
+                        return syncResult(runManager, states);
                     return states
                         .map((state) => `Started triaging ${issueMarkdownLink(repository, state.issue)}.`)
                         .join("\n");

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");
@@ -343,6 +351,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 +375,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 +403,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 +430,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,
@@ -505,6 +511,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,

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,15 +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;
         });
+        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] =
-            findings.length || output.requirementFindings.length
-                ? { ...output, findings }
-                : { findings: [], requirementFindings: [], verdict: "MERGE" };
+            newFindings.length || output.followUps.length
+                ? { ...output, newFindings }
+                : { ...output, newFindings, verdict: "MERGE" };
     }
     return { outputs: next, summary: { discarded, kept } };
 }

package/dist/orchestrator/inline-comments.js

@@ -52,12 +52,6 @@ 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/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,
@@ -146,14 +147,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 || output.requirementFindings.length) {
+    if (output.newFindings.length) {
         return postChangesRequested(input.exec, input.repository, input.pr, reviewer.account, output.newFindings.map((finding) => ({
             fix: "Please address this before merging.",
             issue: finding.body,
             path: finding.path,
-            ...(finding.line == null ? {} : { line: finding.line }),
+            line: finding.line,
             startLine: finding.startLine,
-        })), output.requirementFindings);
+        })));
     }
     return replies[0] ?? "";
 }
@@ -166,52 +167,50 @@ function newFindingToEditorFinding(reviewer, finding) {
     return {
         body: finding.body,
         fix: "Please address this before merging.",
+        line: finding.line,
         path: finding.path,
         reviewer,
-        ...(finding.line == null ? {} : { line: finding.line }),
         ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
-        type: finding.line == null ? "file" : "inline",
+        type: "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.findings.map((finding) => ({
+                fix: finding.fix,
+                issue: finding.issue,
+                line: finding.line,
+                path: finding.path,
+                reviewer,
+                ...(finding.startLine == null ? {} : { startLine: finding.startLine }),
+                type: "inline",
+            }));
         }
-        return [
-            ...output.newFindings.map((finding) => newFindingToEditorFinding(reviewer, finding)),
-            ...requirementFindings,
-        ];
+        return output.newFindings.map((finding) => newFindingToEditorFinding(reviewer, finding));
     });
 }
 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 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);
@@ -266,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,
@@ -310,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,
@@ -349,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");
@@ -425,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) {
@@ -507,8 +511,6 @@ function syntheticReviewThreads(outputs) {
     for (const [reviewer, output] of Object.entries(outputs)) {
         if ("findings" in output) {
             threads[reviewer] = output.findings.flatMap((finding) => {
-                if (finding.line == null)
-                    return [];
                 const commentId = nextCommentId--;
                 return [
                     {
@@ -531,8 +533,6 @@ function syntheticReviewThreads(outputs) {
             continue;
         }
         threads[reviewer] = output.newFindings.flatMap((finding) => {
-            if (finding.line == null)
-                return [];
             const commentId = nextCommentId--;
             return [
                 {
@@ -590,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 });
@@ -721,9 +721,7 @@ export async function runMerge(input) {
                 threads: unresolvedThreads,
             });
             const editorFindings = blockingReviewFindings(reportOutputs);
-            const editableFindings = editableThreads.length
-                ? editorFindings
-                : editorFindings.filter((finding) => finding.type !== "inline");
+            const editableFindings = editorFindings;
             const findingAttemptsExhausted = input.repository.merge.maxThreadResolutionCycles !== 0 &&
                 cycle > input.repository.merge.maxThreadResolutionCycles;
             if (!editableThreads.length &&
@@ -803,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,
                 },