buddy-workbench 0.2.9 → 0.2.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.2.9",
+  "version": "0.2.11",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/branch-health.js

@@ -8,13 +8,14 @@ import { addBranchHealthHistory, listBranchHealthHistory } from '../repositories
 const router = Router();
 const execFileAsync = promisify(execFile);
 const GIT_TIMEOUT = 30 * 1000;
+const COMPLEX_ANALYSIS_MAX_AGE_DAYS = 365;
 
 async function git(folder, args, options = {}) {
   try {
     const result = await execFileAsync('git', args, {
       cwd: folder,
       timeout: GIT_TIMEOUT,
-      maxBuffer: 4 * 1024 * 1024
+      maxBuffer: options.maxBuffer || 4 * 1024 * 1024
     });
     return result.stdout.trim();
   } catch (error) {
@@ -49,9 +50,8 @@ function workspaceRepositoryCandidates(workspaceDir) {
 
 function parseRefList(raw) {
   return raw.split(/\r?\n/).filter(Boolean).map((line) => {
-    const separatorIndex = line.indexOf(' ');
-    const ref = separatorIndex === -1 ? line : line.slice(0, separatorIndex);
-    const hash = separatorIndex === -1 ? '' : line.slice(separatorIndex + 1).trim();
+    const refFields = line.split('\t', 1)[0].trim().split(/\s+/);
+    const [ref, hash] = refFields;
     if (!ref || !hash) return null;
     const remote = ref.startsWith('refs/remotes/');
     const remoteMatch = ref.match(/^refs\/remotes\/([^/]+)\/(.+)$/);
@@ -75,13 +75,61 @@ function parseCommit(raw) {
   };
 }
 
-function parseFirstCommit(raw) {
-  const [timestamp, date, name, email] = raw.split('\x1f');
-  const numericTimestamp = Number(timestamp);
-  return {
-    createdAt: Number.isFinite(numericTimestamp) ? new Date(numericTimestamp * 1000).toISOString() : date || null,
-    creator: { name: name || '', email: email || '' }
-  };
+function parseCommitMetadata(raw) {
+  const commits = new Map();
+  raw.split(/\r?\n/).filter(Boolean).forEach((line) => {
+    const separatorIndex = line.indexOf('\t');
+    if (separatorIndex < 0) return;
+    const metadata = parseCommit(line.slice(separatorIndex + 1));
+    if (metadata?.hash) commits.set(metadata.hash, metadata);
+  });
+  return commits;
+}
+
+function parseCommitGraph(raw) {
+  const parentsByCommit = new Map();
+  const childrenByCommit = new Map();
+  const commitsByHash = new Map();
+  raw.split(/\r?\n/).filter(Boolean).forEach((line) => {
+    const fields = line.split('\x1f');
+    const commit = fields[0];
+    if (!commit) return;
+    const parents = (fields[1] || '').split(' ').filter(Boolean);
+    parentsByCommit.set(commit, parents);
+    const metadata = parseCommit([commit, ...fields.slice(2)].join('\x1f'));
+    if (metadata) commitsByHash.set(commit, metadata);
+    parents.forEach((parent) => {
+      if (!childrenByCommit.has(parent)) childrenByCommit.set(parent, new Set());
+      childrenByCommit.get(parent).add(commit);
+    });
+  });
+  return { parentsByCommit, childrenByCommit, commitsByHash };
+}
+
+function reachableCommits(tip, parentsByCommit) {
+  const seen = new Set();
+  const pending = [tip];
+  while (pending.length) {
+    const commit = pending.pop();
+    if (!commit || seen.has(commit)) continue;
+    seen.add(commit);
+    for (const parent of parentsByCommit.get(commit) || []) pending.push(parent);
+  }
+  return seen;
+}
+
+function isAncestor(ancestor, descendant, childrenByCommit) {
+  if (!ancestor || !descendant) return false;
+  const seen = new Set();
+  const pending = [ancestor];
+  while (pending.length) {
+    const commit = pending.pop();
+    if (commit === descendant) return true;
+    if (seen.has(commit)) continue;
+    seen.add(commit);
+    for (const child of childrenByCommit.get(commit) || []) pending.push(child);
+  }
+  return false;
 }
 
 function isProtectedBranch(name) {
@@ -111,19 +159,17 @@ function healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRe
   return { status: 'keep', label: 'Keep', score };
 }
 
-async function readBranchDetails(folder, branch, refs, targetRef, currentBranch) {
+async function readBranchDetails(folder, branch, refs, targetRef, currentBranch, commit, creator, branchCount, parentsByCommit, childrenByCommit, branchAncestors, targetAncestors) {
   const ref = branch.localRef || branch.remoteRef;
-  const commit = parseCommit(await git(folder, [
-    'show', '-s', '--format=%H%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%cn%x1f%ce', ref
-  ], { allowFailure: true }));
   if (!commit) return null;
 
-  let firstCommit = parseFirstCommit(await git(folder, [
-    'log', '--reverse', '--format=%ct%x1f%aI%x1f%an%x1f%ae', '-1', ref
-  ], { allowFailure: true }));
-  let createdAtSource = 'first commit (inferred)';
+  let firstCommit = creator ? { creator } : null;
+  let createdAtSource = 'not available from bulk scan';
+  const ageDays = dateAgeDays(commit.committedAt || commit.authoredAt);
+  const runComplexAnalysis = ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+  if (!runComplexAnalysis) createdAtSource = 'not analyzed (last commit older than 365 days)';
 
-  if (branch.localRef) {
+  if (runComplexAnalysis && branch.localRef) {
     const reflog = await git(folder, ['reflog', 'show', '--format=%ct%x1f%cI%x1f%gs', branch.localRef], { allowFailure: true });
     const earliestEntry = reflog.split(/\r?\n/).filter(Boolean).at(-1);
     if (earliestEntry) {
@@ -139,27 +185,23 @@ async function readBranchDetails(folder, branch, refs, targetRef, currentBranch)
     }
   }
 
-  const branchCount = Number(await git(folder, ['rev-list', '--count', ref], { allowFailure: true })) || 0;
-  const containingRefs = parseRefList(await git(folder, [
-    'for-each-ref', '--contains', commit.hash, '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'
-  ], { allowFailure: true }));
-  const containingNames = [...new Set(containingRefs.map((item) => item.name).filter((name) => name !== branch.name))];
+  const containingNames = runComplexAnalysis
+    ? [...new Set(refs.filter((item) => item.name !== branch.name && isAncestor(commit.hash, item.hash, childrenByCommit)).map((item) => item.name))]
+    : [];
   const protectedContaining = containingNames.filter(isProtectedBranch);
   // A child branch containing main's commit is not evidence that main was
   // merged into that child. Only protected/default targets count as merge
   // evidence for cleanup decisions in this local-only phase.
   const mergedInto = protectedContaining[0] || null;
-  const merged = Boolean(mergedInto);
-
-  let ahead = 0;
-  let behind = 0;
-  if (targetRef && ref !== targetRef) {
-    const counts = (await git(folder, ['rev-list', '--left-right', '--count', `${targetRef}...${ref}`], { allowFailure: true })).split(/\s+/).map(Number);
-    behind = Number.isFinite(counts[0]) ? counts[0] : 0;
-    ahead = Number.isFinite(counts[1]) ? counts[1] : 0;
+  const merged = runComplexAnalysis ? Boolean(mergedInto) : false;
+
+  let ahead = runComplexAnalysis ? 0 : null;
+  let behind = runComplexAnalysis ? 0 : null;
+  if (runComplexAnalysis && targetRef && ref !== targetRef) {
+    ahead = [...branchAncestors].filter((hash) => !targetAncestors.has(hash)).length;
+    behind = [...targetAncestors].filter((hash) => !branchAncestors.has(hash)).length;
   }
 
-  const ageDays = dateAgeDays(commit.committedAt || commit.authoredAt);
   const isCurrent = !branch.remote && currentBranch === branch.name;
   const isProtected = isProtectedBranch(branch.name);
   const health = healthForBranch({ merged, ahead, ageDays, isCurrent, isProtected, hasRemote: Boolean(branch.remoteRef) });
@@ -178,16 +220,17 @@ async function readBranchDetails(folder, branch, refs, targetRef, currentBranch)
     lastCommit: commit,
     ageDays,
     commitCount: branchCount,
+    analysisSkipped: !runComplexAnalysis,
     ahead,
     behind,
     merged,
     mergedInto,
     mergedIntoAll: protectedContaining,
-    mergeSource: merged ? 'local ancestry (inferred)' : 'not found in local refs',
+    mergeSource: !runComplexAnalysis ? 'skipped (last commit older than 365 days)' : merged ? 'local ancestry (inferred)' : 'not found in local refs',
     openPullRequest: null,
     health,
     reasons: [
-      merged ? `Merged into ${mergedInto}` : 'No containing target branch found',
+      !runComplexAnalysis ? 'Complex ancestry analysis skipped for branches inactive over one year' : merged ? `Merged into ${mergedInto}` : 'No containing target branch found',
       ageDays >= 90 ? `${ageDays} days since last commit` : null,
       ahead > 0 ? `${ahead} commits not in the default branch` : null,
       isCurrent ? 'Currently checked out' : null,
@@ -201,12 +244,22 @@ async function scanRepository(folder) {
   const root = resolve(folder);
   if (!existsSync(join(root, '.git'))) throw new Error(`Not a Git repository: ${root}`);
 
-  const [currentBranch, remoteUrl, refsRaw] = await Promise.all([
+  const [currentBranch, remoteUrl, refsAndMetadataRaw] = await Promise.all([
     git(root, ['branch', '--show-current'], { allowFailure: true }),
     git(root, ['remote', 'get-url', 'origin'], { allowFailure: true }),
-    git(root, ['for-each-ref', '--format=%(refname) %(objectname)', 'refs/heads', 'refs/remotes'])
+    git(root, ['for-each-ref', '--format=%(refname) %(objectname)%09%(objectname)%1f%(objectname:short)%1f%(subject)%1f%(authorname)%1f%(authoremail:trim)%1f%(authordate:iso-strict)%1f%(committerdate:iso-strict)%1f%(committername)%1f%(committeremail:trim)', 'refs/heads', 'refs/remotes'])
   ]);
-  const refs = parseRefList(refsRaw);
+  const refs = parseRefList(refsAndMetadataRaw);
+  const commitMetadata = parseCommitMetadata(refsAndMetadataRaw);
+  const graphTips = [...new Set(refs.filter((item) => {
+    const commit = commitMetadata.get(item.hash);
+    const ageDays = dateAgeDays(commit?.committedAt || commit?.authoredAt);
+    return isProtectedBranch(item.name) || ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+  }).map((item) => item.hash))];
+  const graphRaw = graphTips.length > 0
+    ? await git(root, ['log', '--parents', '--format=%H%x1f%P%x1f%h%x1f%s%x1f%an%x1f%ae%x1f%aI%x1f%cI%x1f%cn%x1f%ce', ...graphTips], { maxBuffer: 128 * 1024 * 1024 })
+    : '';
+  const { parentsByCommit, childrenByCommit, commitsByHash } = parseCommitGraph(graphRaw);
 
   // Remote refs are normalized to their branch name so local and origin/main
   // are presented as one row when both are available.
@@ -223,9 +276,30 @@ async function scanRepository(folder) {
   const targetName = preferredTargets.find((name) => normalized.has(name)) || [...normalized.keys()].find(isProtectedBranch) || null;
   const targetBranch = targetName ? normalized.get(targetName) : null;
   const targetRef = targetBranch?.localRef || targetBranch?.remoteRef || null;
+  const targetHash = refs.find((item) => item.ref === targetRef)?.hash;
+  const targetAncestors = targetHash ? reachableCommits(targetHash, parentsByCommit) : new Set();
   const details = [];
   for (const branch of normalized.values()) {
-    const detail = await readBranchDetails(root, branch, refs, targetRef, currentBranch);
+    const ref = branch.localRef || branch.remoteRef;
+    const tip = refs.find((item) => item.ref === ref)?.hash;
+    const commit = commitMetadata.get(tip) || null;
+    const ageDays = dateAgeDays(commit?.committedAt || commit?.authoredAt);
+    const runComplexAnalysis = ageDays === null || ageDays <= COMPLEX_ANALYSIS_MAX_AGE_DAYS;
+    const branchAncestors = runComplexAnalysis ? reachableCommits(tip, parentsByCommit) : null;
+    const branchCount = branchAncestors?.size ?? null;
+    let creator = null;
+    if (branchAncestors) {
+      let firstCommitTimestamp = Infinity;
+      for (const hash of branchAncestors) {
+        const candidate = commitsByHash.get(hash);
+        const timestamp = Date.parse(candidate?.authoredAt || '');
+        if (candidate && Number.isFinite(timestamp) && timestamp < firstCommitTimestamp) {
+          firstCommitTimestamp = timestamp;
+          creator = candidate.author;
+        }
+      }
+    }
+    const detail = await readBranchDetails(root, branch, refs, targetRef, currentBranch, commit, creator, branchCount, parentsByCommit, childrenByCommit, branchAncestors, targetAncestors);
     if (detail) details.push(detail);
   }
 
@@ -237,8 +311,9 @@ async function scanRepository(folder) {
     scannedAt: new Date().toISOString(),
     analysis: {
       source: 'local Git',
+      complexAnalysisMaxAgeDays: COMPLEX_ANALYSIS_MAX_AGE_DAYS,
       mergeEvidence: 'Local ref ancestry; remote PR history is not queried in this phase.',
-      creationEvidence: 'Local reflog when available, otherwise first commit date.'
+      creationEvidence: 'Local reflog for recently active local branches; older branches skip creation and ancestry analysis.'
     }
   };
 }
@@ -262,6 +337,7 @@ function deletionChecks(branch) {
   if (!branch.hasLocal && !branch.hasRemote) blockers.push('Branch no longer exists in local or origin refs.');
   if (branch.current) blockers.push('The current branch cannot be deleted.');
   if (branch.protected) blockers.push('Protected branch patterns cannot be deleted.');
+  if (branch.analysisSkipped) blockers.push('Complex ancestry analysis was skipped for this branch, so deletion cannot be verified.');
   if (!branch.merged) blockers.push('The branch head is not contained in another local ref.');
   if (branch.ahead > 0) blockers.push(`${branch.ahead} commit(s) are not in the default branch.`);
 

package/server/routes/jira-filters.js

@@ -354,24 +354,49 @@ async function searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates
 }
 
 async function fetchCommentsForIssue(jiraHost, headers, issueKey, maxResults = 50) {
-  try {
-    const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
-    const response = await httpClient.get(url, { headers });
-    if (response.status !== 200) return [];
-    const total = response.data?.total || 0;
-    const comments = Array.isArray(response.data?.comments) ? response.data.comments : [];
-    if (total > comments.length && total > maxResults) {
-      const startAt = Math.max(0, total - maxResults);
-      const latestUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?startAt=${startAt}&maxResults=${maxResults}`;
-      const latestResponse = await httpClient.get(latestUrl, { headers });
-      if (latestResponse.status === 200 && Array.isArray(latestResponse.data?.comments)) {
-        return latestResponse.data.comments;
+  const requestComments = async (url) => {
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt += 1) {
+      const response = await httpClient.get(url, { headers });
+      if (response.status === 200 && Array.isArray(response.data?.comments)) return response;
+      if (response.status !== 429 || attempt >= maxRetries) {
+        const error = new Error(`Jira comments request for ${issueKey} returned HTTP ${response.status}`);
+        error.status = response.status;
+        throw error;
       }
+
+      const retryAfter = response.headers?.['retry-after'] ?? response.headers?.['Retry-After'];
+      const retryAfterSeconds = Number(retryAfter);
+      const retryAfterDate = Date.parse(retryAfter);
+      const delayMs = Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0
+        ? retryAfterSeconds * 1000
+        : Number.isFinite(retryAfterDate)
+          ? Math.max(0, retryAfterDate - Date.now())
+          : Math.min(1000 * (2 ** attempt), 10000);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
-    return comments;
-  } catch {
-    return [];
+  };
+
+  const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
+  const response = await requestComments(url);
+  const total = response.data?.total || 0;
+  const comments = response.data.comments;
+  if (total > comments.length && total > maxResults) {
+    const startAt = Math.max(0, total - maxResults);
+    const latestUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?startAt=${startAt}&maxResults=${maxResults}`;
+    const latestResponse = await requestComments(latestUrl);
+    return latestResponse.data.comments;
+  }
+  return comments;
+}
+
+async function mapInBatches(items, batchSize, mapper) {
+  const results = [];
+  for (let index = 0; index < items.length; index += batchSize) {
+    const batchResults = await Promise.all(items.slice(index, index + batchSize).map(mapper));
+    results.push(...batchResults);
   }
+  return results;
 }
 
 router.get('/recently-created', (_req, res) => {
@@ -409,7 +434,7 @@ router.get('/recently-commented', async (_req, res) => {
     const issues = await searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter');
     const results = [];
 
-    const issueCommentsPromises = issues.map(async (issue) => {
+    const issueComments = await mapInBatches(issues, 5, async (issue) => {
       const key = issue.key;
       const fields = issue.fields || {};
       const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
@@ -436,8 +461,7 @@ router.get('/recently-commented', async (_req, res) => {
       return null;
     });
 
-    const settled = await Promise.all(issueCommentsPromises);
-    for (const item of settled) {
+    for (const item of issueComments) {
       if (item) results.push(item);
     }
 
@@ -478,7 +502,7 @@ router.get('/recently-mentioned', async (_req, res) => {
     const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter', 40);
     const results = [];
 
-    const issueMentionsPromises = issues.slice(0, 30).map(async (issue) => {
+    const issueMentions = await mapInBatches(issues.slice(0, 30), 5, async (issue) => {
       const key = issue.key;
       const fields = issue.fields || {};
       const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
@@ -511,8 +535,7 @@ router.get('/recently-mentioned', async (_req, res) => {
       return null;
     });
 
-    const settled = await Promise.all(issueMentionsPromises);
-    for (const item of settled) {
+    for (const item of issueMentions) {
       if (item) results.push(item);
     }
 

package/server/routes/package-upgrade.js

@@ -12,6 +12,7 @@ import { recordApiError } from '../lib/api-errors.js';
 const router = Router();
 const exec = promisify(execFile);
 const running = new Set();
+const BITBUCKET_REQUEST_BATCH_SIZE = 5;
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 const httpClient = axios.create({
   httpsAgent,
@@ -239,14 +240,24 @@ router.post('/repos/branches', async (req, res) => {
   const repos = repoIds.map((repoId) => data.repos.find((repo) => repo.id === repoId)).filter(Boolean);
   if (!repos.length) return res.json([]);
   try {
-    const remote = await Promise.all(repos.map((repo) => fetchRemoteBranches(repo)));
+    const remote = [];
+    for (let index = 0; index < repos.length; index += BITBUCKET_REQUEST_BATCH_SIZE) {
+      remote.push(...await Promise.all(repos.slice(index, index + BITBUCKET_REQUEST_BATCH_SIZE).map(fetchRemoteBranches)));
+    }
     const branchSets = remote.map(({ branches }) => new Set(branches.map((branch) => branch.name)));
     const commonNames = remote[0].branches.map((branch) => branch.name).filter((name) => branchSets.every((branches) => branches.has(name)));
-    const commonBranches = await Promise.all(commonNames.map(async (name) => {
-      const branches = remote.map(({ base, branches: items }) => ({ base, branch: items.find((item) => item.name === name) })).filter(({ branch }) => branch);
-      const updated = await Promise.all(branches.map(({ base, branch }) => fetchBranchUpdatedAt(base, branch)));
-      return { name, updatedAt: Math.max(...updated.map((item) => item.updatedAt)), rank: Math.min(...updated.map((item) => item.rank)) };
-    }));
+    const commonBranches = [];
+    for (let index = 0; index < commonNames.length; index += BITBUCKET_REQUEST_BATCH_SIZE) {
+      const batch = await Promise.all(commonNames.slice(index, index + BITBUCKET_REQUEST_BATCH_SIZE).map(async (name) => {
+        const branches = remote.map(({ base, branches: items }) => ({ base, branch: items.find((item) => item.name === name) })).filter(({ branch }) => branch);
+        const updated = [];
+        for (let branchIndex = 0; branchIndex < branches.length; branchIndex += BITBUCKET_REQUEST_BATCH_SIZE) {
+          updated.push(...await Promise.all(branches.slice(branchIndex, branchIndex + BITBUCKET_REQUEST_BATCH_SIZE).map(({ base, branch }) => fetchBranchUpdatedAt(base, branch))));
+        }
+        return { name, updatedAt: Math.max(...updated.map((item) => item.updatedAt)), rank: Math.min(...updated.map((item) => item.rank)) };
+      }));
+      commonBranches.push(...batch);
+    }
     commonBranches.sort((a, b) => b.updatedAt - a.updatedAt || a.rank - b.rank || a.name.localeCompare(b.name));
     res.json(commonBranches.map(({ name, updatedAt }) => ({ name, updatedAt: updatedAt ? new Date(updatedAt).toISOString() : null })));
   } catch (error) {

package/server/routes/pr-conflicts.js

@@ -10,6 +10,7 @@ import { readPackageUpgradeData } from '../repositories/package-upgrade.js';
 import { getGitRemoteUrl } from '../services/git.js';
 
 const router = Router();
+const CONFLICT_CHECK_BATCH_SIZE = 5;
 const execFileAsync = promisify(execFile);
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 const client = axios.create({ httpsAgent, validateStatus: () => true });
@@ -335,35 +336,39 @@ router.get('/my-conflicts', async (_req, res) => {
       }
     });
 
-    const conflicts = await Promise.all(values.map(async (pr) => {
-      const project = pr.toRef?.repository?.project?.key;
-      const repository = pr.toRef?.repository?.slug;
-      if (!project || !repository || !pr.id) return null;
-      if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
-
-      const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
-      const baseConflict = {
-        id: pr.id,
-        title: pr.title || `Pull Request #${pr.id}`,
-        repositoryName: pr.toRef?.repository?.name || repository,
-        sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
-        targetBranch: pr.toRef?.displayId || pr.toRef?.id,
-        updatedDate: pr.updatedDate,
-        url: webPullRequestUrl(host, pr)
-      };
-      if (resolutionPr) {
-        return {
-          ...baseConflict,
-          resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
-          resolutionPrId: resolutionPr.id
+    const conflicts = [];
+    for (let index = 0; index < values.length; index += CONFLICT_CHECK_BATCH_SIZE) {
+      const batch = await Promise.all(values.slice(index, index + CONFLICT_CHECK_BATCH_SIZE).map(async (pr) => {
+        const project = pr.toRef?.repository?.project?.key;
+        const repository = pr.toRef?.repository?.slug;
+        if (!project || !repository || !pr.id) return null;
+        if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
+
+        const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
+        const baseConflict = {
+          id: pr.id,
+          title: pr.title || `Pull Request #${pr.id}`,
+          repositoryName: pr.toRef?.repository?.name || repository,
+          sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
+          targetBranch: pr.toRef?.displayId || pr.toRef?.id,
+          updatedDate: pr.updatedDate,
+          url: webPullRequestUrl(host, pr)
         };
-      }
+        if (resolutionPr) {
+          return {
+            ...baseConflict,
+            resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
+            resolutionPrId: resolutionPr.id
+          };
+        }
 
-      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
-      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
-      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
-      return baseConflict;
-    }));
+        const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
+        const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
+        if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
+        return baseConflict;
+      }));
+      conflicts.push(...batch);
+    }
     const sorted = conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
     const unresolved = sorted.filter((pr) => !pr.resolutionPrUrl);
     const resolved = sorted.filter((pr) => pr.resolutionPrUrl);