@doist/doistbot-cli 1.0.2 → 1.0.3

package/sandbox/dist/tasks/issue-triage/fix-dispatch.js

@@ -0,0 +1,190 @@
+import { logger } from '../../core/logging.js';
+import { DefaultLoopEffects } from './fix-loop/effects.js';
+import { runFixLoop } from './fix-loop/runners.js';
+import { attemptFix, buildFixAssessmentSkipReason, shouldAttemptFix } from './fix-attempt.js';
+import { FIX_LOOP_FAILED_REASON_PREFIX } from './fix-failure-reasons.js';
+import { getAutoFixMode } from './repo-config.js';
+function fallbackRepository(input) {
+    return (input.fixAssessment.targetRepo ??
+        (input.clonedRepos.length === 1
+            ? input.clonedRepos[0].repository.fullName
+            : `${input.ctx.owner}/${input.ctx.repo}`));
+}
+function resolveFixTarget(input) {
+    // TODO: Refactor attemptFix to accept a resolved target repo so dispatch and
+    // the legacy engine do not duplicate target-resolution logic.
+    if (input.clonedRepos.length === 0) {
+        return {
+            ok: false,
+            repository: fallbackRepository(input),
+            reason: 'No cloned repositories available for fix attempt.',
+        };
+    }
+    if (input.fixAssessment.targetRepo) {
+        const targetRepo = input.clonedRepos.find((repo) => repo.repository.fullName === input.fixAssessment.targetRepo);
+        if (targetRepo) {
+            return { ok: true, targetRepo };
+        }
+        return {
+            ok: false,
+            repository: fallbackRepository(input),
+            reason: `Unable to resolve a unique target repository from assessment: ${input.fixAssessment.targetRepo}`,
+        };
+    }
+    if (input.clonedRepos.length === 1) {
+        return { ok: true, targetRepo: input.clonedRepos[0] };
+    }
+    return {
+        ok: false,
+        repository: fallbackRepository(input),
+        reason: 'Unable to resolve a unique target repository from assessment: missing targetRepo',
+    };
+}
+function toAttemptFixInput(input) {
+    return {
+        ctx: input.ctx,
+        octokit: input.octokit,
+        triageOutput: input.triageOutput,
+        fixAssessment: input.fixAssessment,
+        clonedRepos: input.clonedRepos,
+        issueTitle: input.issueTitle,
+        issueUrl: input.issueUrl,
+        ghToken: input.ghToken,
+    };
+}
+function stateLogMeta(state) {
+    return {
+        kind: state.kind,
+        ...(state.kind !== 'AWAITING_FIRST_FIX' && 'iteration' in state
+            ? { iteration: state.iteration }
+            : {}),
+        ...('branch' in state && state.branch !== undefined ? { branch: state.branch } : {}),
+        ...('prNumber' in state && state.prNumber !== undefined
+            ? { pr_number: state.prNumber }
+            : {}),
+    };
+}
+function logDryRunTransition({ from, event, to }) {
+    logger.info('DRY RUN: fix loop state transition', {
+        task: 'fix-loop',
+        from: stateLogMeta(from),
+        event: event.kind,
+        to: stateLogMeta(to),
+    });
+}
+function errorReason(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function prUrlFor(targetRepo, prNumber) {
+    return `https://github.com/${targetRepo.repository.fullName}/pull/${prNumber}`;
+}
+export async function runConfiguredFix(input) {
+    const target = resolveFixTarget(input);
+    if (!target.ok) {
+        return { attempted: false, repository: target.repository, reason: target.reason };
+    }
+    const targetRepo = target.targetRepo;
+    let repoConfig;
+    try {
+        repoConfig = await input.loadRepoConfig(targetRepo.repository);
+    }
+    catch (error) {
+        logger.warn('Fix loop config load failed', {
+            task: 'fix-loop',
+            repository: targetRepo.repository.fullName,
+            error: errorReason(error),
+        });
+        return {
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: false,
+            reason: `Fix loop config load failed: ${errorReason(error)}`,
+        };
+    }
+    const autoFixMode = getAutoFixMode(repoConfig, input.ctx.enableAutoFixOverride);
+    if (autoFixMode === 'disabled') {
+        return {
+            attempted: false,
+            repository: targetRepo.repository.fullName,
+            reason: 'Auto fix disabled by repository config.',
+        };
+    }
+    if (autoFixMode === 'one-pass') {
+        return attemptFix(toAttemptFixInput(input));
+    }
+    if (!shouldAttemptFix(input.fixAssessment)) {
+        return {
+            attempted: false,
+            repository: targetRepo.repository.fullName,
+            reason: buildFixAssessmentSkipReason(input.fixAssessment),
+        };
+    }
+    const session = {
+        kind: 'fix-loop',
+        ctx: input.ctx,
+        octokit: input.octokit,
+        triageOutput: input.triageOutput,
+        fixAssessment: input.fixAssessment,
+        targetRepo,
+        issueTitle: input.issueTitle,
+        issueUrl: input.issueUrl,
+        ghToken: input.ghToken,
+        pushToken: input.ctx.githubToken,
+        apiKeys: {
+            openai: input.ctx.openaiApiKey,
+            ...(input.ctx.geminiApiKey !== undefined && { gemini: input.ctx.geminiApiKey }),
+            ...(input.ctx.anthropicApiKey !== undefined && {
+                anthropic: input.ctx.anthropicApiKey,
+            }),
+        },
+    };
+    let finalState;
+    try {
+        finalState = await runFixLoop({
+            effects: new DefaultLoopEffects(session, { dryRun: input.ctx.dryRun }),
+            ...(input.ctx.dryRun ? { onTransition: logDryRunTransition } : {}),
+        });
+    }
+    catch (error) {
+        return {
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: false,
+            reason: `${FIX_LOOP_FAILED_REASON_PREFIX} ${errorReason(error)}`,
+        };
+    }
+    if (finalState.kind === 'PUSHED_AWAITING_CI') {
+        if (input.ctx.dryRun) {
+            return {
+                attempted: true,
+                repository: targetRepo.repository.fullName,
+                prCreated: false,
+                reason: 'Dry run: PR not created.',
+            };
+        }
+        const prNumber = finalState.prNumber;
+        const prUrl = prUrlFor(targetRepo, prNumber);
+        return {
+            attempted: true,
+            repository: targetRepo.repository.fullName,
+            prCreated: true,
+            prUrl,
+            prNumber,
+        };
+    }
+    const reason = finalState.kind === 'DONE_NEEDS_HUMAN'
+        ? finalState.reason
+        : `Fix loop ended in ${finalState.kind}`;
+    return {
+        attempted: true,
+        repository: targetRepo.repository.fullName,
+        prCreated: false,
+        reason,
+        // If a PR was opened earlier in the loop (REVIEWING/ITERATING reached
+        // before DONE_NEEDS_HUMAN), surface it so callers can distinguish a
+        // silent failure from an in-progress PR.
+        ...('prNumber' in finalState && finalState.prNumber !== undefined
+            ? { prNumber: finalState.prNumber }
+            : {}),
+    };
+}

package/sandbox/dist/tasks/issue-triage/fix-failure-reasons.js

@@ -0,0 +1,2 @@
+export const CODEX_CANNOT_FIX_REASON = 'Codex determined fix cannot be applied automatically.';
+export const FIX_LOOP_FAILED_REASON_PREFIX = 'Fix loop failed:';

package/sandbox/dist/tasks/issue-triage/fix-loop/effects.js

@@ -0,0 +1,464 @@
+import { logger } from '../../../core/logging.js';
+import { withRetry } from '../../../core/retry.js';
+import { renderPriorityBadge } from '../../review/github-comment-format.js';
+import { runLocalReview as defaultRunLocalReview } from '../../review/local.js';
+import { parseSeverity } from '../../review/severity.js';
+import { runFixCore as defaultRunFixCore, stripPRTitleSection } from '../fix-attempt.js';
+import { resolveHeroTeamSlug } from '../hero-group-map.js';
+import { FIX_LOOP_START_MARKER } from '../markers.js';
+import { commitAndPushFix as defaultCommitAndPushFix, commitAndPushIteration as defaultCommitAndPushIteration, openDraftFixPR as defaultOpenDraftFixPR, } from '../pr-creator.js';
+export function buildFixLoopStartCommentBody(args) {
+    const p0 = renderPriorityBadge('P0') ?? 'P0';
+    const p1 = renderPriorityBadge('P1') ?? 'P1';
+    return [
+        FIX_LOOP_START_MARKER,
+        '',
+        '### Working on a fix',
+        '',
+        `I've opened a draft PR with an initial fix: ${args.prUrl}`,
+        '',
+        `The PR targets \`${args.targetRepoFullName}\`. I'll review it locally, iterate on ${p0} and ${p1} findings, and run CI. Once everything passes, I'll promote the PR out of draft and request a hero review on it.`,
+    ].join('\n');
+}
+const DRY_RUN_HEAD_SHA = '0'.repeat(40);
+const DRY_RUN_BRANCH = 'doistbot/dry-run';
+const DRY_RUN_PR_NUMBER = 0;
+const FAILURE_CONCLUSIONS = new Set([
+    'failure',
+    'cancelled',
+    'timed_out',
+    'action_required',
+    'startup_failure',
+]);
+const FAILURE_STATUS_STATES = new Set(['error', 'failure']);
+function defaultDeps() {
+    return {
+        runFixCore: defaultRunFixCore,
+        commitAndPushFix: defaultCommitAndPushFix,
+        commitAndPushIteration: defaultCommitAndPushIteration,
+        openDraftFixPR: defaultOpenDraftFixPR,
+        runLocalReview: defaultRunLocalReview,
+    };
+}
+export class DefaultLoopEffects {
+    session;
+    opts;
+    deps;
+    constructor(session, opts = {}, deps = defaultDeps()) {
+        this.session = session;
+        this.opts = opts;
+        this.deps = deps;
+    }
+    logContext(extra = {}) {
+        const session = this.session;
+        return {
+            task: session.kind,
+            delivery_id: session.ctx.deliveryId,
+            source_repository: `${session.ctx.owner}/${session.ctx.repo}`,
+            target_repository: session.targetRepo.repository.fullName,
+            // issue_number identifies the source issue the bot is triaging in
+            // Run 1. Promotion (Run 2) has no source issue, so the field is
+            // emitted only when the session is fix-loop-shaped.
+            ...(session.kind === 'fix-loop' ? { issue_number: session.ctx.issueNumber } : {}),
+            ...extra,
+        };
+    }
+    async runFix(input) {
+        const session = this.session;
+        const result = await this.deps.runFixCore({
+            ctx: session.ctx,
+            triageOutput: session.triageOutput,
+            fixAssessment: session.fixAssessment,
+            targetRepo: session.targetRepo,
+            issueTitle: session.issueTitle,
+            issueUrl: session.issueUrl,
+            ghToken: session.ghToken,
+            ...(input.prevHeadSha !== undefined && { resetTo: input.prevHeadSha }),
+            ...(input.previousFindings !== undefined && {
+                previousFindings: input.previousFindings,
+            }),
+        });
+        if (!result.ok) {
+            return { ok: false, reason: result.reason };
+        }
+        return {
+            ok: true,
+            diff: result.diff,
+            codexOutput: result.codexOutput,
+            generatedPRTitle: result.generatedPRTitle,
+            generatedPRBody: result.generatedPRBody,
+        };
+    }
+    async runReview(input) {
+        const session = this.session;
+        const workspaceDir = this.opts.reviewWorkspaceDir ?? session.targetRepo.localPath;
+        const source = input.reviewBaseSha !== undefined
+            ? { kind: 'sha-range', baseSha: input.reviewBaseSha }
+            : 'base';
+        const result = await this.deps.runLocalReview({
+            workspaceDir,
+            source,
+            apiKeys: session.apiKeys,
+        });
+        if (result.reviewResult.status !== 'reviewed') {
+            // Only `empty_review` means the review actually ran and the
+            // reviewer produced zero comments. The other skip reasons signal
+            // the review pipeline never reached a verdict (no models, no diff
+            // to review, model returned nothing), and an unreviewed fix must
+            // NOT advance toward CI/promotion.
+            if (result.reviewResult.reason === 'empty_review') {
+                logger.info('Review returned no comments; treating as clean', this.logContext({
+                    iteration: input.iteration,
+                }));
+                return { kind: 'reviewed', findings: [], raw: { summary: '', comments: [] } };
+            }
+            logger.warn('Review unverified; escalating', this.logContext({
+                iteration: input.iteration,
+                reason: result.reviewResult.reason,
+            }));
+            return { kind: 'unverified', reason: result.reviewResult.reason };
+        }
+        const review = result.reviewResult.review;
+        const comments = review.comments;
+        const findings = comments.map((c) => ({
+            path: c.path,
+            line: c.line,
+            severity: parseSeverity(c.body),
+            body: c.body,
+        }));
+        return { kind: 'reviewed', findings, raw: review };
+    }
+    async pushCommit(input) {
+        if (input.iteration > 0 && input.branch === undefined) {
+            // Iteration > 0 always appends to an existing branch — opening a
+            // fresh draft PR would orphan the new commit from the original
+            // one. The runner should thread state.branch through; reaching
+            // here means a caller bug.
+            throw new Error(`DefaultLoopEffects.pushCommit: iteration ${input.iteration} requires a branch from the prior push`);
+        }
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would commit and push fix', this.logContext({
+                iteration: input.iteration,
+                diff_lines: input.diff.split('\n').length,
+            }));
+            const isFirstPush = input.branch === undefined;
+            if (isFirstPush) {
+                logger.info('DRY RUN: would open draft fix PR', this.logContext());
+                logger.info('DRY RUN: would post fix-loop start comment on source issue', {
+                    ...this.logContext(),
+                    source_issue_number: this.session.ctx.issueNumber,
+                });
+            }
+            return {
+                headSha: DRY_RUN_HEAD_SHA,
+                branch: input.branch ?? DRY_RUN_BRANCH,
+                prNumber: DRY_RUN_PR_NUMBER,
+            };
+        }
+        if (input.branch === undefined) {
+            return this.pushFirstCommit(input);
+        }
+        return this.pushIteration(input, input.branch);
+    }
+    async pushFirstCommit(input) {
+        const session = this.session;
+        const { branch, headSha } = await this.deps.commitAndPushFix({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            repoLocalPath: session.targetRepo.localPath,
+            githubToken: session.pushToken,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+        });
+        const prResult = await this.deps.openDraftFixPR({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            octokit: session.octokit,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            issueUrl: session.issueUrl,
+            triageAnalysis: session.triageOutput,
+            fixDescription: stripPRTitleSection(input.codexOutput),
+            branch,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+            ...(input.generatedPRBody ? { prBody: input.generatedPRBody } : {}),
+            fixAssessment: session.fixAssessment,
+        });
+        await this.postFixStartedSourceIssueComment({
+            prUrl: prResult.prUrl,
+            prNumber: prResult.prNumber,
+        });
+        return {
+            headSha,
+            branch,
+            prNumber: prResult.prNumber,
+            prUrl: prResult.prUrl,
+        };
+    }
+    async postFixStartedSourceIssueComment(args) {
+        const session = this.session;
+        const body = buildFixLoopStartCommentBody({
+            prUrl: args.prUrl,
+            targetRepoFullName: session.targetRepo.repository.fullName,
+        });
+        try {
+            // Find-or-update by marker so a redelivery (after an opened PR but
+            // a failed response on this side) does not double-post.
+            const existing = await this.findSourceIssueCommentByMarker(FIX_LOOP_START_MARKER);
+            if (existing) {
+                await session.octokit.rest.issues.updateComment({
+                    owner: session.ctx.owner,
+                    repo: session.ctx.repo,
+                    comment_id: existing.id,
+                    body,
+                });
+            }
+            else {
+                await session.octokit.rest.issues.createComment({
+                    owner: session.ctx.owner,
+                    repo: session.ctx.repo,
+                    issue_number: session.ctx.issueNumber,
+                    body,
+                });
+            }
+            logger.info('fix-loop: posted start comment on source issue', this.logContext({
+                pr_number: args.prNumber,
+                source_issue_number: session.ctx.issueNumber,
+            }));
+        }
+        catch (error) {
+            // Comment posting is best-effort — never fail the PR creation if
+            // it errors. The PR is already open and the loop must keep going.
+            logger.warn('fix-loop: failed to post start comment on source issue', this.logContext({
+                pr_number: args.prNumber,
+                source_issue_number: session.ctx.issueNumber,
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    }
+    async findSourceIssueCommentByMarker(marker) {
+        const session = this.session;
+        const comments = await session.octokit.paginate(session.octokit.rest.issues.listComments, {
+            owner: session.ctx.owner,
+            repo: session.ctx.repo,
+            issue_number: session.ctx.issueNumber,
+            per_page: 100,
+        });
+        return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+    }
+    async pushIteration(input, branch) {
+        const session = this.session;
+        // Subsequent iterations must update the existing PR by pushing to the
+        // same branch. commitAndPushFix would generate a fresh branch and
+        // orphan the new commit from the open PR, so we use
+        // commitAndPushIteration.
+        const { headSha } = await this.deps.commitAndPushIteration({
+            repoOwner: session.targetRepo.repository.owner,
+            repoName: session.targetRepo.repository.repo,
+            repoLocalPath: session.targetRepo.localPath,
+            branch,
+            githubToken: session.pushToken,
+            issueNumber: session.ctx.issueNumber,
+            issueTitle: session.issueTitle,
+            ...(input.generatedPRTitle ? { prTitle: input.generatedPRTitle } : {}),
+        });
+        return { headSha, branch };
+    }
+    async applyLabels(input) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would apply labels', this.logContext({ pr_number: input.prNumber, labels: input.labels }));
+            return;
+        }
+        await withRetry(() => this.session.octokit.rest.issues.addLabels({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            issue_number: input.prNumber,
+            labels: input.labels,
+        }));
+    }
+    async postIssueComment(input) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would post issue comment', this.logContext({
+                pr_number: input.prNumber,
+                body_chars: input.body.length,
+                marker: input.marker,
+            }));
+            return;
+        }
+        const owner = this.session.targetRepo.repository.owner;
+        const repo = this.session.targetRepo.repository.repo;
+        const body = input.marker ? `${input.marker}\n\n${input.body}` : input.body;
+        if (input.marker !== undefined) {
+            const existing = await this.findCommentByMarker(input.prNumber, input.marker);
+            if (existing) {
+                await this.session.octokit.rest.issues.updateComment({
+                    owner,
+                    repo,
+                    comment_id: existing.id,
+                    body,
+                });
+                return;
+            }
+        }
+        await this.session.octokit.rest.issues.createComment({
+            owner,
+            repo,
+            issue_number: input.prNumber,
+            body,
+        });
+    }
+    async findCommentByMarker(prNumber, marker) {
+        const comments = await this.session.octokit.paginate(this.session.octokit.rest.issues.listComments, {
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            issue_number: prNumber,
+            per_page: 100,
+        });
+        return comments.find((c) => typeof c.body === 'string' && c.body.includes(marker));
+    }
+    async cloneRepo(_input) {
+        // Cloning is handled by the triage entrypoint before DefaultLoopEffects is
+        // constructed; the cloned repo is supplied via session.targetRepo.
+        return this.session.targetRepo;
+    }
+    async checkCIStatus(headSha) {
+        // Both endpoints collapse history to one entry per name/context. For
+        // checks: `filter=latest` keeps only the most recent run per check
+        // name (matters when a workflow has been re-run). For commit statuses:
+        // /commits/{ref}/status returns one combined object whose `statuses`
+        // array is already the latest entry per context — so we call it
+        // directly (not via paginate, which would yield combined-status
+        // objects, not the inner status entries).
+        const [checkRuns, combined] = await Promise.all([
+            this.session.octokit.paginate(this.session.octokit.rest.checks.listForRef, {
+                owner: this.session.targetRepo.repository.owner,
+                repo: this.session.targetRepo.repository.repo,
+                ref: headSha,
+                filter: 'latest',
+                per_page: 100,
+            }),
+            this.session.octokit.rest.repos.getCombinedStatusForRef({
+                owner: this.session.targetRepo.repository.owner,
+                repo: this.session.targetRepo.repository.repo,
+                ref: headSha,
+            }),
+        ]);
+        const statuses = combined.data.statuses;
+        const failedChecks = [];
+        const pendingChecks = [];
+        let totalEntries = 0;
+        for (const cr of checkRuns) {
+            totalEntries++;
+            const info = {
+                name: cr.name,
+                conclusion: cr.conclusion ?? null,
+                url: cr.html_url ?? cr.details_url ?? '',
+            };
+            if (cr.status !== 'completed') {
+                pendingChecks.push(info);
+                continue;
+            }
+            if (cr.conclusion && FAILURE_CONCLUSIONS.has(cr.conclusion)) {
+                failedChecks.push(info);
+            }
+        }
+        for (const status of statuses) {
+            totalEntries++;
+            const info = {
+                name: status.context,
+                conclusion: status.state ?? null,
+                url: status.target_url ?? '',
+            };
+            if (status.state === 'pending') {
+                pendingChecks.push(info);
+                continue;
+            }
+            if (FAILURE_STATUS_STATES.has(status.state ?? '')) {
+                failedChecks.push(info);
+            }
+        }
+        if (totalEntries === 0) {
+            return { kind: 'no_checks', headSha };
+        }
+        if (failedChecks.length > 0) {
+            return { kind: 'failed', headSha, failedChecks };
+        }
+        if (pendingChecks.length > 0) {
+            return { kind: 'pending', headSha, pendingChecks };
+        }
+        return { kind: 'passed', headSha };
+    }
+    async promoteToReady(prNumber) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would promote PR to ready', this.logContext({
+                pr_number: prNumber,
+            }));
+            return;
+        }
+        // TODO: thread node_id through from the webhook handler's
+        // fetchPRPromotionState so this second pulls.get goes away.
+        const pr = await withRetry(() => this.session.octokit.rest.pulls.get({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            pull_number: prNumber,
+        }));
+        // Idempotency: markPullRequestReadyForReview throws
+        // `UNPROCESSABLE: Pull request is not a draft` if the PR is already
+        // ready. On webhook redelivery the catch block in runPromotionFlow
+        // would re-arm awaiting-ci and loop on every subsequent CI event.
+        if (!pr.data.draft) {
+            return;
+        }
+        await withRetry(() => this.session.octokit.graphql(`mutation($pullRequestId: ID!) {
+                    markPullRequestReadyForReview(input: { pullRequestId: $pullRequestId }) {
+                        pullRequest { isDraft }
+                    }
+                }`, { pullRequestId: pr.data.node_id }));
+    }
+    async applyAskLabel(prNumber) {
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would apply ask label', this.logContext({ pr_number: prNumber }));
+            return;
+        }
+        const labels = await this.session.octokit.paginate(this.session.octokit.rest.issues.listLabelsForRepo, {
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            per_page: 100,
+        });
+        // `\bask\b` matches `ask`, `Ask`, `ask: review`, `Review:Ask`, etc.
+        // without false-positives on labels that merely contain the substring
+        // (e.g. `Type:Task`). The repo-label search is the contract because
+        // the actual label name is repo-specific.
+        const candidates = labels.filter((label) => /\bask\b/i.test(label.name));
+        if (candidates.length === 0) {
+            logger.warn('No ask-style label found on target repo; promoted PR will not be marked for pre-merge review', this.logContext({ pr_number: prNumber }));
+            return;
+        }
+        const chosen = candidates[0].name;
+        if (candidates.length > 1) {
+            logger.info('Multiple ask-style label candidates found; applying the first match', this.logContext({
+                pr_number: prNumber,
+                candidates: candidates.map((c) => c.name),
+                chosen,
+            }));
+        }
+        await this.applyLabels({ prNumber, labels: [chosen] });
+    }
+    async requestHeroReview(prNumber) {
+        const team = resolveHeroTeamSlug(this.session.targetRepo.repository);
+        if (this.opts.dryRun) {
+            logger.info('DRY RUN: would request hero review', this.logContext({
+                pr_number: prNumber,
+                team,
+            }));
+            return;
+        }
+        await withRetry(() => this.session.octokit.rest.pulls.requestReviewers({
+            owner: this.session.targetRepo.repository.owner,
+            repo: this.session.targetRepo.repository.repo,
+            pull_number: prNumber,
+            team_reviewers: [team],
+        }));
+    }
+}

package/sandbox/dist/tasks/issue-triage/fix-loop/effects.types.js

@@ -0,0 +1 @@
+export {};