opencode-magi 0.5.0 → 0.6.0

package/dist/config/resolve.js

@@ -28,7 +28,7 @@ export function reviewerKey(reviewer, index) {
     return reviewer.id ?? `reviewer-${index + 1}`;
 }
 export function triageAgentKey(agent, index) {
-    return agent.id ?? `triage-${index + 1}`;
+    return agent.id ?? `voter-${index + 1}`;
 }
 export function validateReviewerId(id) {
     return ID_PATTERN.test(id);
@@ -104,7 +104,7 @@ export function resolveAgents(config) {
         triageCreator: creator
             ? {
                 ...creator,
-                account: creator.account ?? config.triage?.account ?? "",
+                account: creator.account ?? "",
                 permission: resolveTriageCreatorPermission(agents, creator),
             }
             : undefined,
@@ -179,7 +179,6 @@ export function resolveRepository(config) {
             requiredLabels: config.review?.safety?.requiredLabels ?? [],
         },
         triage: {
-            account: config.triage?.account,
             automation: {
                 clear: config.triage?.automation?.clear ?? ["triage"],
                 close: config.triage?.automation?.close ?? false,
@@ -193,6 +192,7 @@ export function resolveRepository(config) {
             },
             output: config.triage?.output,
             prompts: config.triage?.prompts ?? {},
+            reporter: config.triage?.reporter,
             safety: {
                 allowAuthors: config.triage?.safety?.allowAuthors ?? [],
                 allowMentionActors: config.triage?.safety?.allowMentionActors ?? [],

package/dist/config/validate.js

@@ -40,6 +40,7 @@ const EDITOR_KEYS = new Set([
     "persona",
 ]);
 const TRIAGE_AGENT_KEYS = new Set([
+    "account",
     "id",
     "model",
     "options",
@@ -75,7 +76,6 @@ const MERGE_KEYS = new Set([
     "prompts",
 ]);
 const TRIAGE_KEYS = new Set([
-    "account",
     "agents",
     "automation",
     "categories",
@@ -83,6 +83,7 @@ const TRIAGE_KEYS = new Set([
     "creator",
     "output",
     "prompts",
+    "reporter",
     "safety",
     "worktree",
 ]);
@@ -135,7 +136,6 @@ const MERGE_PROMPT_KEYS = new Set([
     "editGuidelines",
 ]);
 const TRIAGE_PROMPT_KEYS = new Set([
-    "action",
     "acceptance",
     "category",
     "comment",
@@ -357,6 +357,9 @@ function validateTriageAgentList(agents, path, errors, catalog) {
             errors.push(`${path}[${index}].model is required`);
         validateString(agent.model, `${path}[${index}].model`, errors);
         validateModel(agent.model, `${path}[${index}].model`, errors, catalog);
+        if (!agent.account)
+            errors.push(`${path}[${index}].account is required`);
+        validateString(agent.account, `${path}[${index}].account`, errors);
         validateString(agent.persona, `${path}[${index}].persona`, errors);
         if (agent.options != null && !isPlainObject(agent.options))
             errors.push(`${path}[${index}].options must be an object`);
@@ -383,12 +386,16 @@ function validateResolvedReviewers(reviewers, path, errors) {
         accounts.add(reviewer.account);
     }
 }
-function validateResolvedAgentKeys(agents, path, errors) {
+function validateResolvedTriageAgents(agents, path, errors) {
     const keys = new Set();
+    const accounts = new Set();
     for (const agent of agents) {
         if (keys.has(agent.key))
             errors.push(`${path} has duplicate agent key: ${agent.key}`);
         keys.add(agent.key);
+        if (accounts.has(agent.account))
+            errors.push(`${path} has duplicate agent account: ${agent.account}`);
+        accounts.add(agent.account);
     }
 }
 function validateEditor(editor, path, errors, catalog) {
@@ -672,19 +679,26 @@ function validateTriage(config, errors, options) {
     validateKnownKeys(triage, "triage", TRIAGE_KEYS, errors);
     const automation = triage.automation;
     const concurrency = triage.concurrency;
+    const creator = triage.creator;
+    const reporter = typeof triage.reporter === "string" ? triage.reporter : undefined;
     const safety = triage.safety;
-    if (!triage.account)
-        errors.push("triage.account is required");
-    validateString(triage.account, "triage.account", errors);
     if (!triage.agents)
         errors.push("triage.agents is required");
     validateTriageAgentList(triage.agents, "triage.agents", errors, options.modelCatalog);
     if (Array.isArray(triage.agents)) {
-        validateResolvedAgentKeys(resolveAgents(config).triage ?? [], "triage.resolvedAgents", errors);
+        const resolvedTriageAgents = resolveAgents(config).triage ?? [];
+        validateResolvedTriageAgents(resolvedTriageAgents, "triage.resolvedAgents", errors);
+        if (reporter != null &&
+            !resolvedTriageAgents.some((agent) => agent.key === reporter)) {
+            errors.push(`triage.reporter must match a triage agent key: ${reporter}`);
+        }
     }
-    validateTriageCreator(triage.creator, "triage.creator", errors, options.modelCatalog);
-    if (automation?.create && !triage.creator)
+    validateString(triage.reporter, "triage.reporter", errors);
+    validateTriageCreator(creator, "triage.creator", errors, options.modelCatalog);
+    if (automation?.create && !creator)
         errors.push("triage.creator is required when triage.automation.create is true");
+    if (automation?.create && creator && !creator.account)
+        errors.push("triage.creator.account is required when triage.automation.create is true");
     if (automation != null && !isPlainObject(automation)) {
         errors.push("triage.automation must be an object");
     }
@@ -745,10 +759,10 @@ async function validateAuth(config, exec, errors) {
     const agents = resolveAgents(config);
     for (const reviewer of agents.reviewers)
         accounts.add(reviewer.account);
+    for (const agent of agents.triage ?? [])
+        accounts.add(agent.account);
     if (agents.editor)
         accounts.add(agents.editor.account);
-    if (config.triage?.account)
-        accounts.add(config.triage.account);
     if (agents.triageCreator?.account)
         accounts.add(agents.triageCreator.account);
     await Promise.all([...accounts].filter(Boolean).map(async (account) => {
@@ -802,19 +816,18 @@ async function validateRepositoryPermissions(config, exec, errors, warnings) {
             warnings.push(`Could not validate repository permissions for GitHub account: ${reviewer.account} (${error.message})`);
         }
     }));
-    if (config.triage?.account) {
+    await Promise.all((agents.triage ?? []).map(async (agent) => {
         try {
-            const permissions = await fetchPermissions(config, exec, config.triage.account);
+            const permissions = await fetchPermissions(config, exec, agent.account);
             if (!permissions.pull) {
-                errors.push(`GitHub account cannot read repository for issue triage: ${config.triage.account}`);
+                errors.push(`GitHub account cannot read repository for issue triage: ${agent.account}`);
             }
         }
         catch (error) {
-            warnings.push(`Could not validate repository permissions for GitHub account: ${config.triage.account} (${error.message})`);
+            warnings.push(`Could not validate repository permissions for GitHub account: ${agent.account} (${error.message})`);
         }
-    }
-    if (agents.triageCreator?.account &&
-        agents.triageCreator.account !== config.triage?.account) {
+    }));
+    if (agents.triageCreator?.account) {
         try {
             const permissions = await fetchPermissions(config, exec, agents.triageCreator.account);
             if (!permissions.push) {

package/dist/config/worktree.js

@@ -17,3 +17,9 @@ export function worktreeBaseDirs(directory, config = {}) {
         worktreeBaseDir(directory, config, "issue"),
     ];
 }
+export function prRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "pr"), String(input.pr), input.runId);
+}
+export function issueRunWorktreeDir(input) {
+    return join(worktreeBaseDir(input.directory, input.config, "issue"), String(input.issue), input.runId);
+}

package/dist/github/commands.js

@@ -20,6 +20,68 @@ function errorText(error) {
         .filter((item) => typeof item === "string")
         .join("\n");
 }
+async function localCommitExists(exec, worktreePath, sha) {
+    try {
+        await exec(`git cat-file -e ${shellQuote(`${sha}^{commit}`)}`, {
+            cwd: worktreePath,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function pullRequestCommitSource(input) {
+    if (input.source === "base") {
+        return {
+            owner: input.repository.github.owner,
+            refName: input.meta.baseRefName,
+            repo: input.repository.github.repo,
+        };
+    }
+    return {
+        owner: input.meta.headRepositoryOwner?.login ?? input.repository.github.owner,
+        refName: input.meta.headRefName,
+        repo: input.meta.headRepository?.name ?? input.repository.github.repo,
+    };
+}
+async function fetchPullRequestCommitSource(input) {
+    const commitSource = pullRequestCommitSource(input);
+    try {
+        await input.exec(`git fetch --no-tags ${shellQuote(repositoryGitUrl(input.repository, commitSource.owner, commitSource.repo))} ${shellQuote(`refs/heads/${commitSource.refName}`)}`, { cwd: input.worktreePath });
+    }
+    catch (error) {
+        throw new Error(`Could not fetch ${input.source} ref ${commitSource.refName} for #${input.meta.number}: ${errorText(error)}`);
+    }
+}
+export async function ensurePullRequestCommits(input) {
+    const missing = [];
+    for (const commit of input.commits) {
+        if (!(await localCommitExists(input.exec, input.worktreePath, commit.sha))) {
+            missing.push(commit);
+        }
+    }
+    for (const source of new Set(missing.map((commit) => commit.source))) {
+        await fetchPullRequestCommitSource({
+            exec: input.exec,
+            meta: input.meta,
+            repository: input.repository,
+            source,
+            worktreePath: input.worktreePath,
+        });
+    }
+    for (const commit of missing) {
+        if (await localCommitExists(input.exec, input.worktreePath, commit.sha)) {
+            continue;
+        }
+        const source = pullRequestCommitSource({
+            meta: input.meta,
+            repository: input.repository,
+            source: commit.source,
+        });
+        throw new Error(`${commit.label} commit ${commit.sha} is unavailable after fetching ${commit.source} ref ${source.refName}`);
+    }
+}
 function isCheckoutConfigLockError(error) {
     const text = errorText(error);
     return (/could not lock config file/i.test(text) ||
@@ -330,16 +392,43 @@ export async function removeIssueLabels(exec, repository, issue, labels, account
     return removed;
 }
 export async function fetchPullRequestReviews(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100) { nodes { author { login } submittedAt state body commit { oid } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.reviews.nodes;
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviews(first: 100, after: $cursor) { nodes { author { login } submittedAt state body commit { oid } comments(first: 100) { nodes { body path line startLine } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const reviews = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviews;
+        reviews.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub reviews page was truncated");
+    }
+    return reviews.map((review) => ({
+        ...review,
+        comments: review.comments?.nodes ?? [],
+    }));
 }
 export async function fetchPullRequestCommits(exec, repository, pr) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100) { nodes { commit { oid committedDate parents { totalCount } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    return data.data.repository.pullRequest.commits.nodes.map(({ commit }) => ({
+    const query = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { commits(first: 100, after: $cursor) { nodes { commit { oid committedDate parents { totalCount } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commits = [];
+    let cursor;
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.commits;
+        commits.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub commits page was truncated");
+    }
+    return commits.map(({ commit }) => ({
         committedDate: commit.committedDate,
         oid: commit.oid,
         parentCount: commit.parents.totalCount,
@@ -369,38 +458,9 @@ export async function fetchPullRequestSafetyMeta(exec, repository, pr) {
     }
     return { author, changedFiles, files, labels };
 }
-export async function waitForChecks(exec, repository, pr, enabled = repository.checks.waitBeforeReview) {
-    if (!enabled)
-        return undefined;
-    const report = {
-        attempts: 0,
-        excluded: [],
-        failed: [],
-        rerun: [],
-        scopeInside: [],
-        scopeOutsideRecovered: [],
-        scopeOutsideUnresolved: [],
-    };
-    try {
-        await watchChecks(exec, repository, pr);
-        return report;
-    }
-    catch {
-        report.failed = applyCheckExclusions({
-            checks: await fetchFailedChecks(exec, repository, pr),
-            excluded: report.excluded,
-            patterns: repository.checks.exclude,
-        });
-        return report;
-    }
-}
 export async function watchChecks(exec, repository, pr) {
     await exec(`gh pr checks ${pr} --repo ${shellQuote(repoSpecifier(repository))} --watch`);
 }
-export async function fetchFailedChecks(exec, repository, pr) {
-    const checks = await fetchPullRequestChecks(exec, repository, pr);
-    return checks.filter((check) => isFailedCheck(check) || isCancelledCheck(check));
-}
 export function isCancelledCheck(check) {
     return check.bucket === "cancel" || check.state === "CANCELLED";
 }
@@ -472,9 +532,8 @@ export async function fetchMergeQueueRequirement(exec, repository, branch) {
     const rules = JSON.parse(raw);
     return rules.some((rule) => rule.type === "merge_queue");
 }
-export async function createWorktree(exec, repository, pr, root) {
-    const worktreePath = join(root, `pr-${pr}`);
-    const lockKey = `${repoSpecifier(repository)}:${root}`;
+export async function createWorktree(exec, repository, pr, worktreePath) {
+    const lockKey = `${repoSpecifier(repository)}:${dirname(dirname(worktreePath))}`;
     return withWorktreeCreateLock(lockKey, async () => {
         let worktreeAdded = false;
         try {
@@ -591,6 +650,17 @@ export async function waitForMergeQueue(exec, repository, pr, intervalMs = 30_00
         await new Promise((resolve) => setTimeout(resolve, intervalMs));
     }
 }
+export async function waitForAutoMerge(exec, repository, pr, intervalMs = 30_000) {
+    for (;;) {
+        const status = await fetchPullRequestMergeStatus(exec, repository, pr);
+        if (status.state === "MERGED")
+            return "merged";
+        if (status.state !== "OPEN" || status.autoMergeRequest == null) {
+            return "dequeued";
+        }
+        await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
+}
 export async function closePullRequest(exec, repository, pr, account) {
     const token = await ghToken(exec, repository, account);
     return exec(`gh pr close ${pr} --repo ${shellQuote(repoSpecifier(repository))}`, ghTokenEnv(token));
@@ -629,11 +699,49 @@ export async function configureGitIdentity(exec, worktreePath, identity) {
     }
 }
 export async function fetchUnresolvedThreads(exec, repository, pr, author) {
-    const query = `query($owner: String!, $repo: String!, $pr: Int!) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100) { nodes { id isResolved comments(first: 50) { nodes { databaseId author { login } path line body createdAt } } } } } } }`;
-    const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(query)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}`);
-    const data = JSON.parse(raw);
-    const threads = data.data.repository.pullRequest.reviewThreads
-        .nodes;
+    const threadQuery = `query($owner: String!, $repo: String!, $pr: Int!, $cursor: String) { repository(owner: $owner, name: $repo) { pullRequest(number: $pr) { reviewThreads(first: 100, after: $cursor) { nodes { id isResolved comments(first: 100) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } pageInfo { hasNextPage endCursor } } } } }`;
+    const commentQuery = `query($threadId: ID!, $cursor: String) { node(id: $threadId) { ... on PullRequestReviewThread { comments(first: 100, after: $cursor) { nodes { databaseId author { login } path line body createdAt } pageInfo { hasNextPage endCursor } } } } }`;
+    const threads = [];
+    let cursor;
+    async function fetchRemainingComments(threadId, initialCursor) {
+        const comments = [];
+        let commentsCursor = initialCursor;
+        for (;;) {
+            const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(commentQuery)} -F threadId=${shellQuote(threadId)} -F cursor=${shellQuote(commentsCursor)}`);
+            const data = JSON.parse(raw);
+            const connection = data.data.node?.comments;
+            if (!connection)
+                throw new Error("GitHub review thread comments were missing");
+            comments.push(...connection.nodes);
+            if (!connection.pageInfo?.hasNextPage)
+                break;
+            const nextCursor = connection.pageInfo.endCursor;
+            if (!nextCursor)
+                throw new Error("GitHub review thread comments page was truncated");
+            commentsCursor = nextCursor;
+        }
+        return comments;
+    }
+    for (;;) {
+        const cursorFlag = cursor ? ` -F cursor=${shellQuote(cursor)}` : "";
+        const raw = await exec(`gh api${ghHostOption(repository)} graphql -f query=${shellQuote(threadQuery)} -F owner=${shellQuote(repository.github.owner)} -F repo=${shellQuote(repository.github.repo)} -F pr=${pr}${cursorFlag}`);
+        const data = JSON.parse(raw);
+        const connection = data.data.repository.pullRequest.reviewThreads;
+        for (const thread of connection.nodes) {
+            const commentsCursor = thread.comments.pageInfo?.endCursor;
+            if (thread.comments.pageInfo?.hasNextPage) {
+                if (!commentsCursor)
+                    throw new Error("GitHub review thread comments page was truncated");
+                thread.comments.nodes.push(...(await fetchRemainingComments(thread.id, commentsCursor)));
+            }
+        }
+        threads.push(...connection.nodes);
+        if (!connection.pageInfo?.hasNextPage)
+            break;
+        cursor = connection.pageInfo.endCursor;
+        if (!cursor)
+            throw new Error("GitHub review threads page was truncated");
+    }
     return threads.flatMap((thread) => {
         if (thread.isResolved || !thread.comments.nodes.length)
             return [];

package/dist/index.js

@@ -96,6 +96,7 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
     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") {
@@ -110,6 +111,11 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
             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");
@@ -151,13 +157,20 @@ export function parseRunArguments(value, dryRun = false, command = "review") {
                 prTokens.push(token);
         }
     }
-    return { configOverrides, dryRun, prs: parsePrs(prTokens.join(" ")), sync };
+    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") {
@@ -172,6 +185,11 @@ export function parseIssueRunArguments(value, dryRun = false) {
             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");
@@ -210,6 +228,7 @@ export function parseIssueRunArguments(value, dryRun = false) {
         dryRun,
         issues: parseIssues(issueTokens.join(" ")),
         sync,
+        timeoutMs,
     };
 }
 function nextFlagValue(tokens, index, flag) {
@@ -306,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}`;
@@ -482,11 +505,12 @@ export const MagiPlugin = async ({ client, directory }) => {
                         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");
                 },
             }),
@@ -523,11 +547,12 @@ export const MagiPlugin = async ({ client, directory }) => {
                         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");
                 },
             }),
@@ -567,6 +592,7 @@ export const MagiPlugin = async ({ client, directory }) => {
                         repository,
                         signal: context.abort,
                         sync,
+                        timeoutMs: parsed.timeoutMs,
                     }), { signal: context.abort });
                     if (sync)
                         return syncResult(runManager, states);

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,