@revisium/orchestrator 0.2.0-alpha.2 → 0.2.0-alpha.4

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

@@ -1,5 +1,6 @@
 import { execFileSync } from 'node:child_process';
 import { accessSync, constants } from 'node:fs';
+import { defaultIssueAction, hasClosingIssueReference, hasIssueRefToken } from '../run/issue-ref.js';
 const GH_EXECUTABLE_CANDIDATES = ['/opt/homebrew/bin/gh', '/usr/local/bin/gh', '/usr/bin/gh'];
 function resolveGhExecutable() {
     for (const candidate of GH_EXECUTABLE_CANDIDATES) {
@@ -93,46 +94,96 @@ function parseGhJson(raw, label) {
     }
 }
 const NOT_FOUND_RE = /could not resolve|could not find|no pull requests? found|not found/i;
-function resolvePrByBranch(repo, headBranch, baseBranch, execGh) {
+function listPrsByBranch(repo, headBranch, state, execGh) {
     const raw = execGh([
-        'pr', 'list', '--repo', repo, '--head', headBranch, '--state', 'open',
+        'pr', 'list', '--repo', repo, '--head', headBranch, '--state', state,
         '--json', 'number,baseRefName,state',
     ]);
-    const prs = parseGhJson(raw, `pr list --head ${headBranch}`);
-    const onBase = prs.filter((p) => p.baseRefName === baseBranch);
-    if (onBase.length === 0) {
-        return { needsHuman: true, lesson: `No open PR for head branch "${headBranch}" with base "${baseBranch}" in ${repo} - manual review needed` };
-    }
-    if (onBase.length === 1)
-        return { pr_number: onBase[0].number };
-    const candidates = onBase.map((p) => p.number).join(', ');
+    const stateLabel = state === 'all' ? ' --state all' : '';
+    return parseGhJson(raw, `pr list --head ${headBranch}${stateLabel}`);
+}
+function ambiguousBranchPrs(scope, matches, headBranch, baseBranch) {
+    const candidates = matches.map((p) => p.number).join(', ');
+    return {
+        needsHuman: true,
+        lesson: `Ambiguous: ${matches.length} ${scope} PRs for head branch "${headBranch}" targeting base "${baseBranch}" - candidates #${candidates} - manual review needed`,
+    };
+}
+function resolvePrByBranch(repo, headBranch, baseBranch, execGh) {
+    const openPrs = listPrsByBranch(repo, headBranch, 'open', execGh);
+    const openOnBase = openPrs.filter((p) => p.baseRefName === baseBranch);
+    if (openOnBase.length === 1)
+        return { kind: 'open', prNumber: openOnBase[0].number };
+    if (openOnBase.length > 1)
+        return ambiguousBranchPrs('open', openOnBase, headBranch, baseBranch);
+    const allPrs = listPrsByBranch(repo, headBranch, 'all', execGh);
+    const terminalOnBase = allPrs.filter((p) => p.baseRefName === baseBranch && p.state.toUpperCase() !== 'OPEN');
+    if (terminalOnBase.length === 1) {
+        const pr = terminalOnBase[0];
+        const state = pr.state.toUpperCase();
+        if (state === 'MERGED')
+            return { kind: 'merged', prNumber: pr.number };
+        if (state === 'CLOSED')
+            return { kind: 'closed', prNumber: pr.number };
+        return {
+            needsHuman: true,
+            lesson: `Unexpected terminal PR state ${pr.state} for head branch "${headBranch}" targeting base "${baseBranch}" - manual review needed`,
+        };
+    }
+    if (terminalOnBase.length > 1)
+        return ambiguousBranchPrs('terminal', terminalOnBase, headBranch, baseBranch);
     return {
         needsHuman: true,
-        lesson: `Ambiguous: ${onBase.length} open PRs for head branch "${headBranch}" targeting base "${baseBranch}" - candidates #${candidates} - manual review needed`,
+        lesson: `No open PR for head branch "${headBranch}" with base "${baseBranch}" in ${repo} - manual review needed`,
     };
 }
 function fetchPrView(prNumber, repo, execGh) {
     const raw = execGh([
         'pr', 'view', String(prNumber), '--repo', repo,
-        '--json', 'number,url,state,isDraft,baseRefName,headRefName,headRefOid,title,statusCheckRollup,mergeStateStatus,reviewDecision,mergeable',
+        '--json', 'number,url,state,isDraft,baseRefName,headRefName,headRefOid,title,statusCheckRollup,mergeStateStatus,reviewDecision,mergeable,closingIssuesReferences',
     ]);
     return parseGhJson(raw, `pr view #${prNumber}`);
 }
+function terminalBranchResult(result, headBranch, prView) {
+    if (result.kind === 'merged')
+        return { kind: 'merged', prNumber: result.prNumber, prView };
+    return {
+        kind: 'needsHuman',
+        verdict: 'closed',
+        lesson: `pr_closed_externally: PR #${result.prNumber} for "${headBranch}" was closed without merging - manual review needed`,
+        prNumber: result.prNumber,
+        prView,
+    };
+}
+function resolveBranchForOpenPr(input, headBranch, baseBranch, execGh) {
+    const result = resolvePrByBranch(input.repo, headBranch, baseBranch, execGh);
+    if ('needsHuman' in result) {
+        return { kind: 'needsHuman', verdict: 'unresolved', lesson: result.lesson };
+    }
+    if (result.kind === 'open')
+        return { kind: 'open', prNumber: result.prNumber };
+    return terminalBranchResult(result, headBranch, fetchPrView(result.prNumber, input.repo, execGh));
+}
+function canRecoverFromMissingPr(headBranch, resolvedFromBranch, err) {
+    return Boolean(headBranch && !resolvedFromBranch && NOT_FOUND_RE.test(String(err)));
+}
 function handleClosedPr(prNumber, resolvedFromBranch, input, baseBranch, execGh, prView) {
     if (!input.headBranch || resolvedFromBranch) {
-        return { kind: 'needsHuman', verdict: 'closed', lesson: `PR #${prNumber} was closed without merging - manual review needed`, prNumber, prView };
+        return { kind: 'needsHuman', verdict: 'closed', lesson: `pr_closed_externally: PR #${prNumber} was closed without merging - manual review needed`, prNumber, prView };
     }
     const r = resolvePrByBranch(input.repo, input.headBranch, baseBranch, execGh);
     if ('needsHuman' in r) {
-        return { kind: 'needsHuman', verdict: 'closed', lesson: `PR #${prNumber} was closed; ${r.lesson}`, prNumber, prView };
+        return { kind: 'needsHuman', verdict: 'closed', lesson: `pr_closed_externally: PR #${prNumber} was closed; ${r.lesson}`, prNumber, prView };
     }
-    const newPrView = fetchPrView(r.pr_number, input.repo, execGh);
+    const newPrView = fetchPrView(r.prNumber, input.repo, execGh);
+    if (r.kind !== 'open')
+        return terminalBranchResult(r, input.headBranch, newPrView);
     if (newPrView.state === 'MERGED')
-        return { kind: 'merged', prNumber: r.pr_number, prView: newPrView };
+        return { kind: 'merged', prNumber: r.prNumber, prView: newPrView };
     if (newPrView.state === 'CLOSED') {
-        return { kind: 'needsHuman', verdict: 'closed', lesson: `PR #${r.pr_number} (recovered via "${input.headBranch}") is also closed - manual review needed`, prNumber: r.pr_number, prView: newPrView };
+        return { kind: 'needsHuman', verdict: 'closed', lesson: `pr_closed_externally: PR #${r.prNumber} (recovered via "${input.headBranch}") is also closed - manual review needed`, prNumber: r.prNumber, prView: newPrView };
     }
-    return { kind: 'open', prNumber: r.pr_number, prView: newPrView };
+    return { kind: 'open', prNumber: r.prNumber, prView: newPrView };
 }
 function resolveOpenPr(input, baseBranch, execGh) {
     let prNumber = input.prNumber;
@@ -141,10 +192,10 @@ function resolveOpenPr(input, baseBranch, execGh) {
         if (!input.headBranch) {
             return { kind: 'needsHuman', verdict: 'unresolved', lesson: 'ci-poller step has neither pr_number nor head_branch - cannot identify a PR to watch' };
         }
-        const r = resolvePrByBranch(input.repo, input.headBranch, baseBranch, execGh);
-        if ('needsHuman' in r)
-            return { kind: 'needsHuman', verdict: 'unresolved', lesson: r.lesson };
-        prNumber = r.pr_number;
+        const resolved = resolveBranchForOpenPr(input, input.headBranch, baseBranch, execGh);
+        if (resolved.kind !== 'open')
+            return resolved;
+        prNumber = resolved.prNumber;
         resolvedFromBranch = true;
     }
     let prView;
@@ -152,13 +203,13 @@ function resolveOpenPr(input, baseBranch, execGh) {
         prView = fetchPrView(prNumber, input.repo, execGh);
     }
     catch (err) {
-        if (!input.headBranch || resolvedFromBranch || !NOT_FOUND_RE.test(String(err))) {
+        const recoveryHeadBranch = input.headBranch;
+        if (!canRecoverFromMissingPr(recoveryHeadBranch, resolvedFromBranch, err))
             throw err;
-        }
-        const r = resolvePrByBranch(input.repo, input.headBranch, baseBranch, execGh);
-        if ('needsHuman' in r)
-            return { kind: 'needsHuman', verdict: 'unresolved', lesson: r.lesson };
-        prNumber = r.pr_number;
+        const resolved = resolveBranchForOpenPr(input, recoveryHeadBranch, baseBranch, execGh);
+        if (resolved.kind !== 'open')
+            return resolved;
+        prNumber = resolved.prNumber;
         resolvedFromBranch = true;
         prView = fetchPrView(prNumber, input.repo, execGh);
     }
@@ -171,7 +222,7 @@ function resolveOpenPr(input, baseBranch, execGh) {
 function isTerminal(item) {
     if (item.__typename === 'CheckRun')
         return item.status === 'COMPLETED';
-    return item.state !== 'PENDING';
+    return item.state !== 'EXPECTED' && item.state !== 'PENDING';
 }
 function isPassed(item) {
     if (item.__typename === 'CheckRun') {
@@ -193,12 +244,15 @@ function checkResult(item) {
 function isBot(user) {
     return user?.type === 'Bot';
 }
-export function collectCiChecks(items) {
-    const pending = items.length === 0 || items.some((item) => !isTerminal(item));
+export const GITHUB_CHECK_ROLLUP_UNAVAILABLE = 'GitHub check rollup unavailable (re-polling for checks)';
+export function collectCiChecks(items, opts = {}) {
+    const pending = (opts.emptyIsPending === true && items.length === 0) || items.some((item) => !isTerminal(item));
     const ci_passed = !pending && items.every((item) => isPassed(item));
     const pendingNames = items
         .filter((item) => !isTerminal(item))
         .map(checkName);
+    if (opts.emptyIsPending === true && items.length === 0)
+        pendingNames.push(GITHUB_CHECK_ROLLUP_UNAVAILABLE);
     const checks = items.map((item) => ({ name: checkName(item), result: checkResult(item) }));
     return { pending, ci_passed, checks, pendingNames };
 }
@@ -210,30 +264,78 @@ function asRecord(value) {
         return null;
     return value;
 }
+function firstNumber(...values) {
+    for (const value of values) {
+        if (typeof value === 'number')
+            return value;
+    }
+    return undefined;
+}
+// gh api graphql wraps responses in {"data":{...}}; unwrap tolerantly so unit fixtures still work.
+function unwrapGraphqlData(raw) {
+    const top = asRecord(raw);
+    const data = top ? asRecord(top['data']) : null;
+    return data ?? raw;
+}
+function requireGraphqlRecord(value, context, path) {
+    const record = asRecord(value);
+    if (!record)
+        throw new Error(`invalid GraphQL shape in ${context} response: missing ${path}`);
+    return record;
+}
+function requireGraphqlArray(value, context, path) {
+    if (!Array.isArray(value))
+        throw new Error(`invalid GraphQL shape in ${context} response: missing ${path}`);
+    return value;
+}
 function mapReviewThreads(raw) {
-    const root = asRecord(raw);
-    const repository = asRecord(root?.['repository']);
-    const pullRequest = asRecord(repository?.['pullRequest']);
-    const reviewThreads = asRecord(pullRequest?.['reviewThreads']);
-    const nodes = Array.isArray(reviewThreads?.['nodes']) ? reviewThreads.nodes : [];
-    return nodes.flatMap((node) => {
-        const thread = asRecord(node);
-        if (!thread)
-            return [];
-        const comments = asRecord(thread.comments);
-        const firstComment = Array.isArray(comments?.['nodes']) ? asRecord(comments.nodes[0]) : null;
-        const author = asRecord(firstComment?.['author']);
-        return [{
-                id: asStr(thread.id),
-                isResolved: Boolean(thread.isResolved),
-                isOutdated: Boolean(thread.isOutdated),
-                path: asStr(thread.path) || undefined,
-                line: typeof thread.line === 'number' ? thread.line : undefined,
-                author: asStr(author?.['login']) || undefined,
-                body: compactBody(asStr(firstComment?.['body'])),
-                url: asStr(firstComment?.['url']) || undefined,
-            }];
-    });
+    const context = 'reviewThreads';
+    const root = requireGraphqlRecord(unwrapGraphqlData(raw), context, 'root');
+    const repository = requireGraphqlRecord(root['repository'], context, 'repository');
+    const pullRequest = requireGraphqlRecord(repository['pullRequest'], context, 'repository.pullRequest');
+    const reviewThreads = requireGraphqlRecord(pullRequest['reviewThreads'], context, 'repository.pullRequest.reviewThreads');
+    const nodes = requireGraphqlArray(reviewThreads['nodes'], context, 'repository.pullRequest.reviewThreads.nodes');
+    const pageInfo = asRecord(reviewThreads['pageInfo']);
+    const hasNextPage = pageInfo?.['hasNextPage'] === true;
+    return { threads: nodes.flatMap((node) => {
+            const thread = asRecord(node);
+            if (!thread)
+                return [];
+            const comments = asRecord(thread.comments);
+            const commentNodes = Array.isArray(comments?.['nodes']) ? comments.nodes.flatMap((comment) => {
+                const record = asRecord(comment);
+                return record ? [record] : [];
+            }) : [];
+            const firstComment = commentNodes[0] ?? null;
+            const author = asRecord(firstComment?.['author']);
+            const path = asStr(thread.path) || undefined;
+            const line = firstNumber(thread.line, firstComment?.['line']);
+            const originalLine = firstNumber(thread.originalLine, firstComment?.['originalLine']);
+            return [{
+                    item: {
+                        id: asStr(thread.id),
+                        isResolved: Boolean(thread.isResolved),
+                        isOutdated: Boolean(thread.isOutdated),
+                        path,
+                        line,
+                        originalLine,
+                        author: asStr(author?.['login']) || undefined,
+                        body: compactBody(asStr(firstComment?.['body'])),
+                        url: asStr(firstComment?.['url']) || undefined,
+                    },
+                    comments: commentNodes.map((comment) => {
+                        const commentAuthor = asRecord(comment['author']);
+                        return {
+                            path,
+                            line: firstNumber(comment['line'], thread.line),
+                            originalLine: firstNumber(comment['originalLine'], thread.originalLine),
+                            author: asStr(commentAuthor?.['login']) || undefined,
+                            body: asStr(comment['body']),
+                            url: asStr(comment['url']) || undefined,
+                        };
+                    }),
+                }];
+        }), hasNextPage };
 }
 function splitRepo(repo) {
     const [owner, name] = repo.split('/');
@@ -245,7 +347,7 @@ function fetchReviewThreads(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){reviewThreads(first:100){nodes{id,isResolved,isOutdated,path,line,comments(first:1){nodes{body,url,author{login}}}}}}}}',
+        '-f', 'query=query($owner:String!,$name:String!,$number:Int!){repository(owner:$owner,name:$name){pullRequest(number:$number){reviewThreads(first:100){pageInfo{hasNextPage}nodes{id,isResolved,isOutdated,path,line,originalLine,comments(first:100){nodes{body,url,line,originalLine,author{login}}}}}}}}',
         '-f', `owner=${owner}`,
         '-f', `name=${name}`,
         '-F', `number=${prNumber}`,
@@ -253,12 +355,15 @@ function fetchReviewThreads(repo, prNumber, execGh) {
     return mapReviewThreads(parseGhJson(raw, `review-threads #${prNumber}`));
 }
 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 context = 'required-checks';
+    const root = requireGraphqlRecord(unwrapGraphqlData(raw), context, 'root');
+    const repository = requireGraphqlRecord(root['repository'], context, 'repository');
+    const pullRequest = requireGraphqlRecord(repository['pullRequest'], context, 'repository.pullRequest');
+    if (pullRequest['statusCheckRollup'] === null)
+        throw new Error(GITHUB_CHECK_ROLLUP_UNAVAILABLE);
+    const rollup = requireGraphqlRecord(pullRequest['statusCheckRollup'], context, 'repository.pullRequest.statusCheckRollup');
+    const contexts = requireGraphqlRecord(rollup['contexts'], context, 'repository.pullRequest.statusCheckRollup.contexts');
+    const nodes = requireGraphqlArray(contexts['nodes'], context, 'repository.pullRequest.statusCheckRollup.contexts.nodes');
     const required = new Set();
     for (const node of nodes) {
         const ctx = asRecord(node);
@@ -281,13 +386,56 @@ export function fetchRequiredCheckNames(repo, prNumber, execGh) {
     ]);
     return mapRequiredCheckNames(parseGhJson(raw, `required-checks #${prNumber}`));
 }
+function reviewLineOf(item) {
+    return firstNumber(item.line, item.originalLine, item.original_line);
+}
+function preciseReviewLocationOf(item) {
+    const line = reviewLineOf(item);
+    return item.path && typeof line === 'number' ? `${item.path}:${line}` : '';
+}
+function feedbackMatchEvidence(item) {
+    const location = preciseReviewLocationOf(item);
+    if (location === '')
+        return null;
+    const url = item.html_url ?? item.url ?? '';
+    const author = (item.author ?? item.user?.login ?? '').toLowerCase();
+    const body = compactBody(item.body);
+    const contentKey = author !== '' && body !== '' ? [author, body].join('\0') : '';
+    return { location, url, contentKey };
+}
+function isStaleThreadFeedback(comment, staleThreadEvidence) {
+    const commentEvidence = feedbackMatchEvidence(comment);
+    if (!commentEvidence || !staleThreadEvidence)
+        return false;
+    return staleThreadEvidence
+        .filter((staleEvidence) => staleEvidence.location === commentEvidence.location)
+        .some((staleEvidence) => {
+        if (commentEvidence.url !== '' && staleEvidence.url !== '') {
+            return commentEvidence.url === staleEvidence.url;
+        }
+        return commentEvidence.contentKey !== '' && commentEvidence.contentKey === staleEvidence.contentKey;
+    });
+}
 function collectReviewThreads(input, prNumber, execGh) {
-    const threads = input.includeReviewThreads === false ? [] : fetchReviewThreads(input.repo, prNumber, execGh);
-    const unresolved = threads.filter((thread) => !thread.isResolved && !thread.isOutdated);
+    const fetched = input.includeReviewThreads === false
+        ? { threads: [], hasNextPage: false }
+        : fetchReviewThreads(input.repo, prNumber, execGh);
+    const threads = fetched.threads;
+    const unresolved = threads
+        .filter((thread) => !thread.item.isResolved && !thread.item.isOutdated)
+        .map((thread) => thread.item);
     return {
-        included: input.includeReviewThreads !== false,
-        unresolvedCount: unresolved.length,
-        items: unresolved.slice(0, 20),
+        reviewThreads: {
+            included: input.includeReviewThreads !== false,
+            unresolvedCount: unresolved.length,
+            items: unresolved,
+            ...(fetched.hasNextPage ? { truncated: true } : {}),
+        },
+        staleThreadEvidence: threads
+            .filter((thread) => thread.item.isResolved || thread.item.isOutdated)
+            .flatMap((thread) => thread.comments)
+            .map(feedbackMatchEvidence)
+            .filter((evidence) => evidence !== null),
     };
 }
 function fetchComments(input, prNumber, execGh) {
@@ -413,7 +561,7 @@ function compactCheckLists(checks) {
     const pass = [];
     const fail = [];
     for (const check of checks) {
-        if (['QUEUED', 'IN_PROGRESS', 'PENDING'].includes(check.result)) {
+        if (['EXPECTED', 'QUEUED', 'IN_PROGRESS', 'PENDING'].includes(check.result)) {
             pending.push(check.name);
             continue;
         }
@@ -461,7 +609,7 @@ function providerState(checks, botComments) {
 }
 function locationOf(item) {
     const path = item.path ?? item.component ?? '';
-    return item.line ? `${path}:${item.line}` : path;
+    return typeof item.line === 'number' ? `${path}:${item.line}` : path;
 }
 function providerWaitFeedback(state, botComments) {
     const codeRabbit = state.codeRabbit;
@@ -476,9 +624,6 @@ function providerWaitFeedback(state, botComments) {
             resumeAfter: extractResumeHint(botComments),
         }];
 }
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 function issueRefTitleTag(issueRef, repo) {
     return issueRef.repo.toLowerCase() === repo.toLowerCase()
         ? `#${issueRef.number}`
@@ -487,25 +632,15 @@ function issueRefTitleTag(issueRef, repo) {
 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)
+function issueLinkageFeedback(issueRef, issueAction, repo, pr) {
+    if (!issueRef || issueAction === 'none')
         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))
+    if (!hasIssueRefToken(pr.title, issueRef, repo))
         missing.push(`title missing ${issueTag}`);
     if (missing.length === 0)
         return [];
@@ -515,6 +650,24 @@ function issueLinkageFeedback(issueRef, repo, pr) {
             evidence: `${missing.join('; ')} (head=${pr.head ?? ''}, title=${pr.title ?? ''})`,
         }];
 }
+function issueCloseFeedback(issueRef, issueAction, repo, prView) {
+    if (issueAction !== 'close' || !issueRef || hasClosingIssueReference(prView?.closingIssuesReferences, issueRef))
+        return [];
+    const issueTag = issueRefTitleTag(issueRef, repo);
+    return [{
+            source: 'issue_auto_close',
+            summary: `PR does not auto-close ${issueTag}`,
+            evidence: `GitHub closingIssuesReferences does not include ${issueTag}`,
+        }];
+}
+// Bot logins whose comments are purely informational and safe to suppress.
+// Anything not in this list surfaces in developerFixes to avoid silent suppression.
+const KNOWN_INFORMATIONAL_BOTS = new Set([
+    'sonarqubecloud[bot]',
+    'cursor[bot]',
+    'linear-app[bot]',
+    'deepsource-autofix[bot]',
+]);
 function buildFeedback(input) {
     const developerFixes = [
         ...input.checks.fail.map((name) => ({ source: 'ci', summary: `Fix failing check: ${name}`, evidence: name })),
@@ -540,6 +693,13 @@ function buildFeedback(input) {
             author: review.user?.login ?? '',
             evidence: review.state,
         })),
+        ...(input.reviewThreads.truncated
+            ? [{
+                    source: 'review_threads_truncated',
+                    summary: 'Review thread data is incomplete; fetch all review thread pages before declaring the PR ready.',
+                    evidence: 'GitHub reviewThreads pageInfo.hasNextPage=true',
+                }]
+            : []),
         ...input.reviewThreads.items.map((thread) => ({
             source: 'review_thread',
             summary: thread.body,
@@ -548,6 +708,15 @@ function buildFeedback(input) {
             evidence: thread.url ?? thread.id,
         })),
         ...codeRabbitActionableFeedback(input.coderabbitReviews ?? [], input.botComments, new Set(input.reviewThreads.items.map((thread) => locationOf(thread)).filter((loc) => loc !== ''))),
+        ...input.botComments
+            .filter((comment) => !isCodeRabbit(comment.user) && !KNOWN_INFORMATIONAL_BOTS.has(comment.user?.login ?? ''))
+            .filter((comment) => !isStaleThreadFeedback(comment, input.staleThreadEvidence))
+            .map((comment) => ({
+            source: 'bot_comment',
+            summary: compactBody(comment.body),
+            author: comment.user?.login ?? 'bot',
+            evidence: comment.user?.login ?? 'bot',
+        })),
     ];
     const reviewerQuestions = input.humanComments
         .filter((comment) => comment.body.includes('?'))
@@ -563,10 +732,11 @@ function buildFeedback(input) {
             ? [{ 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 ?? {}),
+        ...issueLinkageFeedback(input.issueRef, input.issueAction, input.repo, input.pr ?? {}),
+        ...issueCloseFeedback(input.issueRef, input.issueAction, input.repo, input.prView),
     ];
     const ignoredNoise = input.botComments
-        .filter((comment) => !comment.user?.login.toLowerCase().includes('coderabbit'))
+        .filter((comment) => !isCodeRabbit(comment.user) && KNOWN_INFORMATIONAL_BOTS.has(comment.user?.login ?? ''))
         .map((comment) => ({ source: comment.user?.login ?? 'bot', summary: compactBody(comment.body) }));
     const residualRisks = [
         ...(input.reviewThreads.included ? [] : ['Review threads were not requested.']),
@@ -620,7 +790,9 @@ function buildEmptyFeedback(input) {
         humanComments: [],
         botComments: [],
         issueRef: input.issueRef,
-        repo: '',
+        issueAction: input.issueAction,
+        repo: input.repo ?? '',
+        prView: input.prView,
     });
 }
 function buildMergedReadiness(input, resolved) {
@@ -636,7 +808,7 @@ function buildMergedReadiness(input, resolved) {
         sonar: emptySonar(sonarConfigured),
         nextAction: 'none',
         evidence: [`PR #${resolved.prNumber} is merged.`],
-        feedback: buildEmptyFeedback({ sonarConfigured, includeReviewThreads }),
+        feedback: buildEmptyFeedback({ sonarConfigured, includeReviewThreads, issueRef: input.issueRef, issueAction: input.issueAction, repo: input.repo, prView: resolved.prView }),
         ciSummary: { ...emptyCiSummary(true), ...(input.issueRef ? { issueRef: input.issueRef } : {}) },
         ...(input.issueRef ? { issueRef: input.issueRef } : {}),
     };
@@ -644,7 +816,7 @@ function buildMergedReadiness(input, resolved) {
 function buildNeedsHumanReadiness(input, resolved) {
     const includeReviewThreads = input.includeReviewThreads !== false;
     const sonarConfigured = Boolean(input.sonarProject);
-    const feedback = buildEmptyFeedback({ sonarConfigured, includeReviewThreads });
+    const feedback = buildEmptyFeedback({ sonarConfigured, includeReviewThreads, issueRef: input.issueRef, issueAction: input.issueAction, repo: input.repo, prView: resolved.prView });
     return {
         verdict: resolved.verdict === 'closed' ? 'closed' : 'needs_human',
         pr: resolved.prNumber ? prFromView(resolved.prNumber, resolved.prView) : emptyPr(input.prNumber, resolved.verdict),
@@ -661,6 +833,9 @@ function buildNeedsHumanReadiness(input, resolved) {
     };
 }
 function buildWaitingReadiness(input) {
+    const checkLists = input.checkLists.list.length === 0 && input.ci.pendingNames.length > 0
+        ? { ...input.checkLists, pending: input.ci.pendingNames }
+        : input.checkLists;
     const pendingCodeRabbit = input.ci.pendingNames.find((name) => name.toLowerCase().includes('coderabbit'));
     const pendingProviderState = pendingCodeRabbit
         ? {
@@ -673,7 +848,7 @@ function buildWaitingReadiness(input) {
         }
         : {};
     const feedback = buildFeedback({
-        checks: input.checkLists,
+        checks: checkLists,
         providerState: pendingProviderState,
         sonar: emptySonar(input.sonarConfigured),
         reviewDecision: input.prView.reviewDecision ?? '',
@@ -682,8 +857,10 @@ function buildWaitingReadiness(input) {
         humanComments: [],
         botComments: [],
         issueRef: input.issueRef,
+        issueAction: input.issueAction,
         repo: input.repo,
         pr: { head: input.prView.headRefName, title: input.prView.title },
+        prView: input.prView,
     });
     const providerWait = pendingCodeRabbit
         ? [{
@@ -698,7 +875,7 @@ function buildWaitingReadiness(input) {
     return {
         verdict: 'waiting',
         pr: prFromView(input.prNumber, input.prView),
-        checks: input.checkLists,
+        checks: checkLists,
         reviewDecision: input.prView.reviewDecision ?? '',
         reviewThreads: input.reviewThreads,
         providerState: pendingProviderState,
@@ -733,6 +910,7 @@ function readinessAction(input) {
     return { verdict: 'ready', nextAction: 'ready_for_merge_gate' };
 }
 export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSonar = defaultFetchSonar) {
+    input = { ...input, issueAction: input.issueAction ?? defaultIssueAction(input.issueRef) };
     const baseBranch = input.baseBranch ?? 'master';
     const resolved = resolveOpenPr(input, baseBranch, execGh);
     if (resolved.kind === 'merged') {
@@ -743,9 +921,9 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
     }
     const { prNumber, prView } = resolved;
     const checks = prView.statusCheckRollup ?? [];
-    const ci = collectCiChecks(checks);
+    const ci = collectCiChecks(checks, { emptyIsPending: prView.statusCheckRollup === null });
     const checkLists = compactCheckLists(ci.checks);
-    const reviewThreads = collectReviewThreads(input, prNumber, execGh);
+    const { reviewThreads, staleThreadEvidence } = collectReviewThreads(input, prNumber, execGh);
     const sonarConfigured = Boolean(input.sonarProject);
     if (prView.isDraft === true) {
         return buildWaitingReadiness({
@@ -757,6 +935,7 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
             reviewThreads,
             sonarConfigured,
             issueRef: input.issueRef,
+            issueAction: input.issueAction,
             evidence: [`PR #${prNumber} is still draft.`],
             isDraft: true,
         });
@@ -771,6 +950,7 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
             reviewThreads,
             sonarConfigured,
             issueRef: input.issueRef,
+            issueAction: input.issueAction,
             evidence: ci.pendingNames.length > 0 ? [`Pending checks: ${ci.pendingNames.join(', ')}`] : ['No check rollup entries are registered yet.'],
         });
     }
@@ -794,10 +974,13 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         humanReviews: comments.human_reviews,
         humanComments: comments.human_comments,
         botComments: comments.bot_comments,
+        staleThreadEvidence,
         coderabbitReviews: comments.coderabbit_reviews,
         issueRef: input.issueRef,
+        issueAction: input.issueAction,
         repo: input.repo,
         pr: { head: prView.headRefName, title: prView.title },
+        prView,
     });
     const ciSummary = {
         ci_passed: ci.ci_passed,
@@ -826,7 +1009,9 @@ export async function collectPrReadiness(input, execGh = defaultExecGh, fetchSon
         nextAction,
         evidence: [
             `PR #${prNumber} state=${prView.state ?? 'unknown'} draft=${Boolean(prView.isDraft)}`,
-            `checks pass=${checkLists.pass.length} fail=${checkLists.fail.length} pending=${checkLists.pending.length}`,
+            checkLists.list.length === 0
+                ? 'checks: none registered'
+                : `checks pass=${checkLists.pass.length} fail=${checkLists.fail.length} pending=${checkLists.pending.length}`,
             ...(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
@@ -846,6 +1031,7 @@ export function toReadinessInput(input) {
         baseBranch: input.base_branch,
         sonarProject: input.sonar_project,
         issueRef: input.issue_ref,
+        issueAction: input.issue_action,
         includeComments: true,
         includeReviewThreads: false,
     };