@revisium/orchestrator 0.1.0-alpha.9 → 0.1.0

package/dist/poller/pr-readiness-core.js

@@ -115,7 +115,7 @@ function resolvePrByBranch(repo, headBranch, baseBranch, execGh) {
 function fetchPrView(prNumber, repo, execGh) {
     const raw = execGh([
         'pr', 'view', String(prNumber), '--repo', repo,
-        '--json', 'number,url,state,isDraft,baseRefName,headRefName,headRefOid,statusCheckRollup,mergeStateStatus,reviewDecision,mergeable',
+        '--json', 'number,url,state,isDraft,baseRefName,headRefName,headRefOid,title,statusCheckRollup,mergeStateStatus,reviewDecision,mergeable',
     ]);
     return parseGhJson(raw, `pr view #${prNumber}`);
 }
@@ -253,6 +253,48 @@ function fetchReviewThreads(repo, prNumber, execGh) {
     ]);
     return mapReviewThreads(parseGhJson(raw, `review-threads #${prNumber}`));
 }
+/** Map the statusCheckRollup contexts GraphQL payload to the SET of check names branch protection
+ *  marks REQUIRED. The check name matches {@link checkName}'s convention so it joins cleanly against
+ *  CI failure names: CheckRun → `name`, StatusContext → `context`. */
+function mapRequiredCheckNames(raw) {
+    const root = asRecord(raw);
+    const repository = asRecord(root?.['repository']);
+    const pullRequest = asRecord(repository?.['pullRequest']);
+    const rollup = asRecord(pullRequest?.['statusCheckRollup']);
+    const contexts = asRecord(rollup?.['contexts']);
+    const nodes = Array.isArray(contexts?.['nodes']) ? contexts.nodes : [];
+    const required = new Set();
+    for (const node of nodes) {
+        const ctx = asRecord(node);
+        if (!ctx || ctx['isRequired'] !== true)
+            continue;
+        // CheckRun carries `name`; StatusContext carries `context` — mirror checkName().
+        const checkName = asStr(ctx['name']) || asStr(ctx['context']);
+        if (checkName)
+            required.add(checkName);
+    }
+    return required;
+}
+/**
+ * fetchRequiredCheckNames — the SET of check names branch protection marks REQUIRED for this PR.
+ *
+ * `gh pr view --json statusCheckRollup` (fetchPrView) does NOT carry isRequired, so this issues a
+ * dedicated GraphQL read mirroring {@link fetchReviewThreads}. `isRequired` lives on
+ * StatusCheckRollupContext and needs the `pullRequestNumber:` arg. Used by pollPr to limit the
+ * `ci_changes` verdict to required-check failures (advisory checks — Sonar/CodeRabbit — must not
+ * trigger a rework loop). Throws on a gh error so callers can apply the fail-safe fallback.
+ */
+export function fetchRequiredCheckNames(repo, prNumber, execGh) {
+    const { owner, name } = splitRepo(repo);
+    const raw = execGh([
+        'api', 'graphql',
+        '-f', 'query=query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){statusCheckRollup{contexts(first:100){nodes{__typename ... on CheckRun{name isRequired(pullRequestNumber:$number)} ... on StatusContext{context isRequired(pullRequestNumber:$number)}}}}}}}',
+        '-f', `owner=${owner}`,
+        '-f', `name=${name}`,
+        '-F', `number=${prNumber}`,
+    ]);
+    return mapRequiredCheckNames(parseGhJson(raw, `required-checks #${prNumber}`));
+}
 function collectReviewThreads(input, prNumber, execGh) {
     const threads = input.includeReviewThreads === false ? [] : fetchReviewThreads(input.repo, prNumber, execGh);
     const unresolved = threads.filter((thread) => !thread.isResolved && !thread.isOutdated);
@@ -264,7 +306,7 @@ function collectReviewThreads(input, prNumber, execGh) {
 }
 function fetchComments(input, prNumber, execGh) {
     if (input.includeComments === false) {
-        return { human_reviews: [], human_comments: [], bot_comments: [] };
+        return { human_reviews: [], human_comments: [], bot_comments: [], coderabbit_reviews: [] };
     }
     const reviewsRaw = execGh(['api', `repos/${input.repo}/pulls/${prNumber}/reviews`]);
     const reviews = parseGhJson(reviewsRaw, `reviews #${prNumber}`);
@@ -273,36 +315,149 @@ function fetchComments(input, prNumber, execGh) {
     const issueCommentsRaw = execGh(['api', `repos/${input.repo}/issues/${prNumber}/comments`]);
     const issueComments = parseGhJson(issueCommentsRaw, `issue-comments #${prNumber}`);
     const allComments = [...reviewComments, ...issueComments];
+    // reviews come back chronological; keep only the latest per author so a stale review never
+    // overrides a newer one. Mirror this for CodeRabbit (a Bot author, hence excluded from the human
+    // map) — otherwise a stale actionable CodeRabbit body keeps a PR stuck even after a newer clean
+    // review (#142 Finding #2).
     const latestHumanReviewByAuthor = new Map();
+    const latestCodeRabbitReviewByAuthor = new Map();
     for (const review of reviews) {
-        if (!review.user || isBot(review.user))
+        if (!review.user)
+            continue;
+        if (isBot(review.user)) {
+            if (isCodeRabbit(review.user))
+                latestCodeRabbitReviewByAuthor.set(review.user.login, review);
             continue;
+        }
         latestHumanReviewByAuthor.set(review.user.login, review);
     }
     return {
         human_reviews: [...latestHumanReviewByAuthor.values()],
         human_comments: allComments.filter((comment) => !isBot(comment.user)),
         bot_comments: allComments.filter((comment) => isBot(comment.user)),
+        // CodeRabbit review bodies are excluded from human_reviews above (they are Bot-authored). They
+        // carry actionable findings as a top-level review body, so keep them for buildFeedback (#142).
+        coderabbit_reviews: [...latestCodeRabbitReviewByAuthor.values()],
     };
 }
+function isCodeRabbit(user) {
+    return (user?.login.toLowerCase() ?? '').includes('coderabbit');
+}
+/** Classify a single CodeRabbit body into a non-actionable provider-WAIT reason (or '' for none).
+ *  Single source of truth shared by codeRabbitCommentReason (drives providerWait) and
+ *  isCodeRabbitActionable (so a provider-wait body is never ALSO emitted as a developerFix — #144). */
+function codeRabbitProviderWaitReason(rawBody) {
+    const body = rawBody.toLowerCase();
+    if (/rate.limit|provider.limit|quota|capacity|temporar/.test(body) && /did not start|could not start|not start|unable to start|paused/.test(body)) {
+        return 'provider_limit';
+    }
+    if (/review in progress|reviewing|processing/.test(body))
+        return 'review_in_progress';
+    if (/skipped|did not review|no files to review/.test(body))
+        return 'skipped';
+    if (/no actionable comments|no issues found|looks good/.test(body))
+        return 'no_actionable_comments';
+    return '';
+}
 function codeRabbitCommentReason(comments) {
     for (const comment of comments) {
-        const login = comment.user?.login.toLowerCase() ?? '';
-        if (!login.includes('coderabbit'))
+        if (!isCodeRabbit(comment.user))
             continue;
-        const body = comment.body.toLowerCase();
-        if (/rate.limit|provider.limit|quota|capacity|temporar/.test(body) && /did not start|could not start|not start|unable to start|paused/.test(body)) {
-            return 'provider_limit';
-        }
-        if (/review in progress|reviewing|processing/.test(body))
-            return 'review_in_progress';
-        if (/skipped|did not review|no files to review/.test(body))
-            return 'skipped';
-        if (/no actionable comments|no issues found|looks good/.test(body))
-            return 'no_actionable_comments';
+        const reason = codeRabbitProviderWaitReason(comment.body);
+        if (reason)
+            return reason;
     }
     return '';
 }
+/** Best-effort extraction of a "retry in N <unit>" hint from a bot comment body, e.g.
+ *  "retry in 10 min". Returns null when no hint is present — the caller must keep the
+ *  raw evidence either way. Case-insensitive and intentionally lenient. */
+function extractResumeHint(comments) {
+    for (const comment of comments) {
+        if (!isCodeRabbit(comment.user))
+            continue;
+        const match = comment.body.match(/\/retry[^.]*?(\d+)\s*(min|minute|hour|sec)/i);
+        if (match) {
+            const unit = match[2].toLowerCase().startsWith('min') ? 'min' : match[2].toLowerCase().startsWith('hour') ? 'hour' : 'sec';
+            return `retry in ${match[1]} ${unit}`;
+        }
+    }
+    return null;
+}
+// CodeRabbit's own structured markers for a finding that still needs developer action. A review
+// body or comment carrying any of these is an actionable blocker — UNLESS it is one of the
+// non-actionable states classified by codeRabbitCommentReason (provider_limit / review_in_progress
+// / skipped / no_actionable_comments), or it has been addressed/resolved/outdated.
+const CODERABBIT_FINDING_MARKERS = [
+    /⚠️\s*potential issue/i,
+    /🛠️\s*refactor suggestion/i,
+    /⚠️\s*outside diff range/i,
+    /🧹\s*nitpick/i,
+];
+// "Actionable comments posted: N" — the count CodeRabbit prints atop a review summary. N>0 means
+// the review found work; N=0 (handled as no_actionable_comments) is explicitly NOT a blocker.
+const CODERABBIT_ACTIONABLE_COUNT_RE = /actionable comments posted:\s*(\d+)/i;
+// A finding CodeRabbit reports as already handled. Anchored to CodeRabbit's own addressed-markers
+// rather than bare words so a live finding whose prose merely mentions e.g. "remove these outdated
+// comments" or "unresolved promise" survives. Such evidence is stale and must NOT remain a blocker.
+const CODERABBIT_ADDRESSED_RE = /✅\s*addressed|\baddressed in\b|marked as resolved|now outdated|marked (?:as )?outdated/i;
+/** True when a CodeRabbit review-body / comment text reports a finding that still needs developer
+ *  action. Conservative — returns false (item dropped, not kept as a blocker) when the body is:
+ *  an explicit `Actionable comments posted: 0`; a non-actionable provider-WAIT state (so a wait is
+ *  never ALSO a developerFix — #144); or carries an addressed/resolved/outdated marker. */
+function isCodeRabbitActionable(body) {
+    const countMatch = body.match(CODERABBIT_ACTIONABLE_COUNT_RE);
+    if (countMatch && Number(countMatch[1]) === 0)
+        return false;
+    if (codeRabbitProviderWaitReason(body) !== '')
+        return false;
+    if (CODERABBIT_ADDRESSED_RE.test(body))
+        return false;
+    if (countMatch && Number(countMatch[1]) > 0)
+        return true;
+    return CODERABBIT_FINDING_MARKERS.some((marker) => marker.test(body));
+}
+/** Actionable CodeRabbit feedback that arrives as a top-level review body or bot comment rather
+ *  than a resolvable GraphQL review thread. `fetchComments` already retrieves this data (bot reviews
+ *  and bot comments) but buildFeedback never routed it to developerFixes; an actual finding therefore
+ *  vanished (#142). Review bodies come from the `reviews` REST call independent of includeReviewThreads,
+ *  so this also covers the poll path. The non-actionable provider states (provider_limit /
+ *  review_in_progress / skipped / no_actionable_comments) stay with providerWait — they are excluded
+ *  here so the WAIT and FIXES buckets never collapse (#144).
+ *
+ *  `threadLocations` carries the path:line of unresolved review threads already emitted as the
+ *  richer `review_thread` developerFix; a bot comment at the same location is the SAME inline
+ *  finding (the thread's first comment), so it is skipped to avoid emitting it twice (#142
+ *  Finding #1). Only non-empty locations dedup — a comment with no path:line is never matched. */
+function codeRabbitActionableFeedback(reviews, botComments, threadLocations = new Set()) {
+    const items = [];
+    for (const review of reviews) {
+        if (!isCodeRabbit(review.user) || !isCodeRabbitActionable(review.body))
+            continue;
+        items.push({
+            source: 'coderabbit_review_body',
+            summary: compactBody(review.body),
+            author: review.user?.login ?? '',
+            location: '',
+            evidence: compactBody(review.body),
+        });
+    }
+    for (const comment of botComments) {
+        if (!isCodeRabbit(comment.user) || !isCodeRabbitActionable(comment.body))
+            continue;
+        const location = locationOf(comment);
+        if (location && threadLocations.has(location))
+            continue;
+        items.push({
+            source: 'coderabbit_comment',
+            summary: compactBody(comment.body),
+            author: comment.user?.login ?? '',
+            location,
+            evidence: compactBody(comment.body),
+        });
+    }
+    return items;
+}
 function compactCheckLists(checks) {
     const terminal = [];
     const pending = [];
@@ -359,11 +514,63 @@ function locationOf(item) {
     const path = item.path ?? item.component ?? '';
     return item.line ? `${path}:${item.line}` : path;
 }
-function providerWaitFeedback(state) {
+function providerWaitFeedback(state, botComments) {
     const codeRabbit = state.codeRabbit;
     if (codeRabbit?.state !== 'waiting')
         return [];
-    return [{ provider: 'CodeRabbit', reason: codeRabbit.reason, evidence: codeRabbit.evidence ?? codeRabbit.statusContext }];
+    // This function is reached on the TERMINAL path (collectPrReadiness only calls buildFeedback
+    // after the ci.pending gate). By then any CodeRabbit check is terminal, so a rate-limit /
+    // review-in-progress BOT COMMENT is necessarily stale relative to the current green head —
+    // it is informational, NOT a readiness blocker. A genuinely-pending CodeRabbit check is
+    // caught earlier by the pending gate and surfaced as a blocking providerWait (see
+    // buildWaitingReadiness), so the two cases are distinguishable via `blocking`.
+    return [{
+            provider: 'CodeRabbit',
+            reason: codeRabbit.reason,
+            evidence: codeRabbit.evidence ?? codeRabbit.statusContext,
+            blocking: false,
+            nature: 'informational',
+            resumeAfter: extractResumeHint(botComments),
+        }];
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function issueRefTitleTag(issueRef, repo) {
+    return issueRef.repo.toLowerCase() === repo.toLowerCase()
+        ? `#${issueRef.number}`
+        : `${issueRef.repo}#${issueRef.number}`;
+}
+function hasIssueBranchToken(head, issueRef) {
+    return new RegExp(`(?:^|[/-])issue-${issueRef.number}(?:-|$)`).test(head ?? '');
+}
+function hasIssueTitleToken(title, issueRef, repo) {
+    const boundaryBefore = String.raw `(?:^|[\s([{"'])`;
+    const boundaryAfter = String.raw `(?=$|[^A-Za-z0-9_-])`;
+    const qualified = new RegExp(`${boundaryBefore}${escapeRegExp(`${issueRef.repo}#${issueRef.number}`)}${boundaryAfter}`, 'i');
+    if (qualified.test(title ?? ''))
+        return true;
+    if (issueRef.repo.toLowerCase() !== repo.toLowerCase())
+        return false;
+    return new RegExp(`${boundaryBefore}#${issueRef.number}${boundaryAfter}`).test(title ?? '');
+}
+function issueLinkageFeedback(issueRef, repo, pr) {
+    if (!issueRef)
+        return [];
+    const issueBranch = `issue-${issueRef.number}`;
+    const issueTag = issueRefTitleTag(issueRef, repo);
+    const missing = [];
+    if (!hasIssueBranchToken(pr.head, issueRef))
+        missing.push(`branch missing ${issueBranch}`);
+    if (!hasIssueTitleToken(pr.title, issueRef, repo))
+        missing.push(`title missing ${issueTag}`);
+    if (missing.length === 0)
+        return [];
+    return [{
+            source: 'issue_ref_linkage',
+            summary: `PR is missing issueRef linkage for ${issueTag}`,
+            evidence: `${missing.join('; ')} (head=${pr.head ?? ''}, title=${pr.title ?? ''})`,
+        }];
 }
 function buildFeedback(input) {
     const developerFixes = [
@@ -397,6 +604,12 @@ function buildFeedback(input) {
             location: locationOf(thread),
             evidence: thread.url ?? thread.id,
         })),
+        // Actionable CodeRabbit feedback delivered as a review body / bot comment rather than a
+        // resolvable review thread (#142). Appended after review_thread items so the thread-aware
+        // classification keeps producing the leading developerFix where threads are present. Pass the
+        // thread path:line locations so a bot comment for a thread already emitted above is not
+        // emitted a second time (#142 Finding #1).
+        ...codeRabbitActionableFeedback(input.coderabbitReviews ?? [], input.botComments, new Set(input.reviewThreads.items.map((thread) => locationOf(thread)).filter((loc) => loc !== ''))),
     ];
     const reviewerQuestions = input.humanComments
         .filter((comment) => comment.body.includes('?'))
@@ -406,12 +619,13 @@ function buildFeedback(input) {
         author: comment.user?.login ?? '',
         location: locationOf(comment),
     }));
-    const providerWait = providerWaitFeedback(input.providerState);
+    const providerWait = providerWaitFeedback(input.providerState, input.botComments);
     const humanDecisions = [
         ...(input.reviewDecision && input.reviewDecision !== 'APPROVED'
             ? [{ source: 'github_review_decision', summary: `Review decision is ${input.reviewDecision}` }]
             : []),
         ...(input.sonar.unavailable ? [{ source: 'sonar', summary: 'Sonar was configured but unavailable.' }] : []),
+        ...issueLinkageFeedback(input.issueRef, input.repo, input.pr ?? {}),
     ];
     const ignoredNoise = input.botComments
         .filter((comment) => !comment.user?.login.toLowerCase().includes('coderabbit'))
@@ -431,6 +645,7 @@ function emptyPr(prNumber, state = '') {
         base: '',
         head: '',
         headSha: '',
+        title: '',
         mergeState: '',
     };
 }
@@ -443,6 +658,7 @@ function prFromView(prNumber, view) {
         base: view?.baseRefName ?? '',
         head: view?.headRefName ?? '',
         headSha: view?.headRefOid ?? '',
+        title: view?.title ?? '',
         mergeState: view?.mergeStateStatus ?? '',
     };
 }
@@ -465,6 +681,8 @@ function buildEmptyFeedback(input) {
         humanReviews: [],
         humanComments: [],
         botComments: [],
+        issueRef: input.issueRef,
+        repo: '',
     });
 }
 function buildMergedReadiness(input, resolved) {
@@ -481,7 +699,8 @@ function buildMergedReadiness(input, resolved) {
         nextAction: 'none',
         evidence: [`PR #${resolved.prNumber} is merged.`],
         feedback: buildEmptyFeedback({ sonarConfigured, includeReviewThreads }),
-        ciSummary: emptyCiSummary(true),
+        ciSummary: { ...emptyCiSummary(true), ...(input.issueRef ? { issueRef: input.issueRef } : {}) },
+        ...(input.issueRef ? { issueRef: input.issueRef } : {}),
     };
 }
 function buildNeedsHumanReadiness(input, resolved) {
@@ -499,47 +718,83 @@ function buildNeedsHumanReadiness(input, resolved) {
         nextAction: 'human_decision',
         evidence: [resolved.lesson],
         feedback: { ...feedback, humanDecisions: [{ source: 'pr_resolution', summary: resolved.lesson }] },
-        ciSummary: emptyCiSummary(false),
+        ciSummary: { ...emptyCiSummary(false), ...(input.issueRef ? { issueRef: input.issueRef } : {}) },
+        ...(input.issueRef ? { issueRef: input.issueRef } : {}),
     };
 }
 function buildWaitingReadiness(input) {
+    // The pending path previously left providerState empty and built providerWait from it (also
+    // empty), so a genuinely-pending CodeRabbit check was never explained as a provider wait.
+    // Synthesize a blocking providerState/providerWait from the pending check names so the output
+    // surfaces WHY the wait is blocking — mirroring the informational entry emitted on the
+    // terminal path. This does not change the verdict (still waiting/watcher_wait).
+    const pendingCodeRabbit = input.ci.pendingNames.find((name) => name.toLowerCase().includes('coderabbit'));
+    const pendingProviderState = pendingCodeRabbit
+        ? {
+            codeRabbit: {
+                state: 'waiting',
+                reason: 'check_pending',
+                statusContext: 'IN_PROGRESS',
+                evidence: 'CodeRabbit check is still pending for the current head — waiting is blocking.',
+            },
+        }
+        : {};
     const feedback = buildFeedback({
         checks: input.checkLists,
-        providerState: {},
+        providerState: pendingProviderState,
         sonar: emptySonar(input.sonarConfigured),
         reviewDecision: input.prView.reviewDecision ?? '',
         reviewThreads: input.reviewThreads,
         humanReviews: [],
         humanComments: [],
         botComments: [],
+        issueRef: input.issueRef,
+        repo: input.repo,
+        pr: { head: input.prView.headRefName, title: input.prView.title },
     });
+    // buildFeedback -> providerWaitFeedback classifies from providerState, but on the pending path
+    // the wait IS blocking (a live check), so emit a blocking item in place of the synthesized one.
+    const providerWait = pendingCodeRabbit
+        ? [{
+                provider: 'CodeRabbit',
+                reason: 'check_pending',
+                evidence: 'CodeRabbit check is still pending for the current head — waiting is blocking.',
+                blocking: true,
+                nature: 'blocking',
+                resumeAfter: null,
+            }]
+        : feedback.providerWait;
     return {
         verdict: 'waiting',
         pr: prFromView(input.prNumber, input.prView),
         checks: input.checkLists,
         reviewDecision: input.prView.reviewDecision ?? '',
         reviewThreads: input.reviewThreads,
-        providerState: {},
+        providerState: pendingProviderState,
         sonar: emptySonar(input.sonarConfigured),
         nextAction: 'watcher_wait',
         evidence: input.evidence,
-        feedback,
+        feedback: { ...feedback, providerWait },
         ciSummary: {
             ci_passed: false,
             checks: input.ci.checks,
             ...(input.isDraft ? { isDraft: true } : {}),
+            ...(input.issueRef ? { issueRef: input.issueRef } : {}),
             sonar_issues: [],
             sonar_hotspots_to_review: [],
             human_reviews: [],
             human_comments: [],
             bot_comments: [],
         },
+        ...(input.issueRef ? { issueRef: input.issueRef } : {}),
     };
 }
 function readinessAction(input) {
-    if (input.providers.codeRabbit?.reason === 'provider_limit' || input.providers.codeRabbit?.reason === 'review_in_progress') {
-        return { verdict: 'waiting', nextAction: 'watcher_wait' };
-    }
+    // NOTE: a CodeRabbit provider_limit / review_in_progress bot comment is intentionally NOT a
+    // `waiting` verdict here. This function is only reached after the ci.pending gate (see
+    // collectPrReadiness), so every check is already terminal — such a comment is stale relative
+    // to the current green head and is surfaced as an informational providerWait instead. A
+    // genuinely-pending CodeRabbit check is handled by the pending gate before this point.
     if (!input.ci.ci_passed || input.feedback.developerFixes.length > 0) {
         return { verdict: 'needs_work', nextAction: 'developer_fix' };
     }
@@ -568,24 +823,28 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
     const sonarConfigured = Boolean(input.sonarProject);
     if (prView.isDraft === true) {
         return buildWaitingReadiness({
+            repo: input.repo,
             prNumber,
             prView,
             checkLists,
             ci,
             reviewThreads,
             sonarConfigured,
+            issueRef: input.issueRef,
             evidence: [`PR #${prNumber} is still draft.`],
             isDraft: true,
         });
     }
     if (ci.pending) {
         return buildWaitingReadiness({
+            repo: input.repo,
             prNumber,
             prView,
             checkLists,
             ci,
             reviewThreads,
             sonarConfigured,
+            issueRef: input.issueRef,
             evidence: ci.pendingNames.length > 0 ? [`Pending checks: ${ci.pendingNames.join(', ')}`] : ['No check rollup entries are registered yet.'],
         });
     }
@@ -609,6 +868,10 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         humanReviews: comments.human_reviews,
         humanComments: comments.human_comments,
         botComments: comments.bot_comments,
+        coderabbitReviews: comments.coderabbit_reviews,
+        issueRef: input.issueRef,
+        repo: input.repo,
+        pr: { head: prView.headRefName, title: prView.title },
     });
     const ciSummary = {
         ci_passed: ci.ci_passed,
@@ -616,6 +879,7 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         mergeStateStatus: prView.mergeStateStatus,
         reviewDecision: prView.reviewDecision,
         mergeable: prView.mergeable,
+        ...(input.issueRef ? { issueRef: input.issueRef } : {}),
         sonar_issues: sonar.issues,
         sonar_hotspots_to_review: sonar.hotspots,
         human_reviews: comments.human_reviews,
@@ -623,7 +887,8 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         bot_comments: comments.bot_comments,
         ...(sonar.unavailable ? { sonar_unavailable: true } : {}),
     };
-    const { verdict, nextAction } = readinessAction({ ci, feedback, providers });
+    const { verdict, nextAction } = readinessAction({ ci, feedback });
+    const hasInformationalProviderWait = feedback.providerWait.some((item) => item.blocking === false);
     return {
         verdict,
         pr: prFromView(prNumber, prView),
@@ -636,10 +901,15 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         evidence: [
             `PR #${prNumber} state=${prView.state ?? 'unknown'} draft=${Boolean(prView.isDraft)}`,
             `checks pass=${checkLists.pass.length} fail=${checkLists.fail.length} pending=${checkLists.pending.length}`,
-            ...(providers.codeRabbit?.reason === 'provider_limit' ? ['CodeRabbit provider/rate limit comment overrides green status.'] : []),
+            ...(input.issueRef ? [`issueRef ${issueRefTitleTag(input.issueRef, input.repo)} expected in branch and title`] : []),
+            ...(providers.codeRabbit?.reason === 'provider_limit' ? ['CodeRabbit provider/rate limit comment detected.'] : []),
+            ...(verdict === 'ready' && hasInformationalProviderWait
+                ? ['Provider wait is informational (stale CodeRabbit rate-limit comment); not blocking readiness.']
+                : []),
         ],
         feedback,
         ciSummary,
+        ...(input.issueRef ? { issueRef: input.issueRef } : {}),
     };
 }
 export function toReadinessInput(input) {
@@ -649,6 +919,7 @@ export function toReadinessInput(input) {
         headBranch: input.head_branch,
         baseBranch: input.base_branch,
         sonarProject: input.sonar_project,
+        issueRef: input.issue_ref,
         includeComments: true,
         includeReviewThreads: false,
     };