claude-teammate 0.1.152 → 0.1.154

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-teammate",
-  "version": "0.1.152",
+  "version": "0.1.154",
   "description": "CLI bootstrapper for Claude Teammate.",
   "license": "MIT",
   "type": "module",

package/src/commands/status.js

@@ -53,6 +53,20 @@ export async function runStatusCommand({ projectRoot, args = [] }) {
       process.stdout.write(`Last PR error: ${state.lastPrError}\n`);
     }
 
+    const pollerCurrent = state.pollerCurrent || {};
+    if (pollerCurrent.jira) {
+      process.stdout.write(`Current Jira item: ${pollerCurrent.jira}\n`);
+    }
+    if (pollerCurrent.github) {
+      process.stdout.write(`Current GitHub item: ${formatQueueIdLabel(pollerCurrent.github, "#")}\n`);
+    }
+    if (pollerCurrent.draftPr) {
+      process.stdout.write(`Current Draft PR: ${formatQueueIdLabel(pollerCurrent.draftPr, "!")}\n`);
+    }
+    if (pollerCurrent.reviewPr) {
+      process.stdout.write(`Current Review PR: ${formatQueueIdLabel(pollerCurrent.reviewPr, "!")}\n`);
+    }
+
     if (Array.isArray(state.issues) && state.issues.length > 0) {
       process.stdout.write("Issues:\n");
       for (const issue of state.issues) {
@@ -79,6 +93,15 @@ export async function runStatusCommand({ projectRoot, args = [] }) {
         );
       }
     }
+
+    if (Array.isArray(state.reviewPrs) && state.reviewPrs.length > 0) {
+      process.stdout.write("Review PRs:\n");
+      for (const pullRequest of state.reviewPrs) {
+        process.stdout.write(
+          `- ${formatForgeQueueLabel(pullRequest.repoUrl, pullRequest.pullRequestNumber)}${pullRequest.title ? ` | ${pullRequest.title}` : ""}${Number.isInteger(pullRequest.suggestionsCount) ? ` | suggestions: ${pullRequest.suggestionsCount}` : ""}\n`
+        );
+      }
+    }
   }
 }
 
@@ -92,3 +115,12 @@ function formatForgeQueueLabel(repoUrl, itemNumber) {
     return `repo #${itemNumber}`;
   }
 }
+
+function formatQueueIdLabel(queueId, separator) {
+  const value = String(queueId || "").trim();
+  if (!value) {
+    return "";
+  }
+  const [repoUrl, itemNumber] = value.split(separator);
+  return formatForgeQueueLabel(repoUrl, itemNumber);
+}

package/src/commands/worker.js

@@ -170,29 +170,30 @@ export async function runWorkerCommand({ projectRoot }) {
     ...previousState,
     projectRoot,
     startedAt: new Date().toISOString(),
-    lastPollAt: null,
-    lastSuccessAt: null,
+    lastPollAt: previousState.lastPollAt ?? null,
+    lastSuccessAt: previousState.lastSuccessAt ?? null,
     lastError: null,
-    issueCount: 0,
-    issues: [],
-    lastGitHubPollAt: null,
-    lastGitHubSuccessAt: null,
+    issueCount: previousState.issueCount ?? 0,
+    issues: Array.isArray(previousState.issues) ? previousState.issues : [],
+    lastGitHubPollAt: previousState.lastGitHubPollAt ?? null,
+    lastGitHubSuccessAt: previousState.lastGitHubSuccessAt ?? null,
     lastGitHubError: null,
-    githubIssueCount: 0,
-    githubIssues: [],
-    lastPrPollAt: null,
-    lastPrSuccessAt: null,
+    githubIssueCount: previousState.githubIssueCount ?? 0,
+    githubIssues: Array.isArray(previousState.githubIssues) ? previousState.githubIssues : [],
+    lastPrPollAt: previousState.lastPrPollAt ?? null,
+    lastPrSuccessAt: previousState.lastPrSuccessAt ?? null,
     lastPrError: null,
-    draftPrCount: 0,
-    draftPrs: [],
+    draftPrCount: previousState.draftPrCount ?? 0,
+    draftPrs: Array.isArray(previousState.draftPrs) ? previousState.draftPrs : [],
     prCommentReview: buildPrSubtaskState(previousState.prCommentReview),
     prImplementation: buildPrSubtaskState(previousState.prImplementation),
-    lastReviewPollAt: null,
-    lastReviewSuccessAt: null,
+    lastReviewPollAt: previousState.lastReviewPollAt ?? null,
+    lastReviewSuccessAt: previousState.lastReviewSuccessAt ?? null,
     lastReviewError: null,
-    reviewPrCount: 0,
-    reviewPrs: [],
-    pollerBusy: { jira: false, github: false, draftPr: false, reviewPr: false }
+    reviewPrCount: previousState.reviewPrCount ?? 0,
+    reviewPrs: Array.isArray(previousState.reviewPrs) ? previousState.reviewPrs : [],
+    pollerBusy: { jira: false, github: false, draftPr: false, reviewPr: false },
+    pollerCurrent: { jira: "", github: "", draftPr: "", reviewPr: "" }
   };
 
   const updatePrSubtaskState = async (key, updates) => {
@@ -255,8 +256,15 @@ export async function runWorkerCommand({ projectRoot }) {
     await writeState(runtimePaths.stateFile, state);
     await runPoll("", "Jira", state, async () => {
       const result = await jira.fetchAssignedIssues();
-      const processedIssues = [];
+      const queuedIssues = result.issues
+        .map((issue) => buildQueuedJiraIssueState(issue))
+        .filter((issue) => shouldDisplayIssueInState(issue));
+      state.issueCount = result.total;
+      state.issues = queuedIssues;
+      await writeState(runtimePaths.stateFile, state);
       for (const issue of result.issues) {
+        state.pollerCurrent.jira = String(issue?.key || "");
+        await writeState(runtimePaths.stateFile, state);
         const processed = await processJiraIssue({
           issue,
           jira,
@@ -267,15 +275,17 @@ export async function runWorkerCommand({ projectRoot }) {
           runtimePaths,
           logger
         });
-        processedIssues.push(processed);
+        reconcileQueueEntry(state.issues, processed, (entry) => entry?.key === issue.key, shouldDisplayIssueInState);
+        await writeState(runtimePaths.stateFile, state);
       }
-      const activeIssues = processedIssues.filter((issue) => shouldDisplayIssueInState(issue));
+      state.pollerCurrent.jira = "";
       return {
-        stateUpdates: { issueCount: result.total, issues: activeIssues },
+        stateUpdates: { issueCount: result.total, issues: state.issues },
         logInfo: { issues: result.issues.length, assigned: result.total }
       };
     }, { stateFile: runtimePaths.stateFile, logger, flagRef: jiraFlag });
     state.pollerBusy.jira = false;
+    state.pollerCurrent.jira = "";
     await writeState(runtimePaths.stateFile, state);
   };
 
@@ -289,7 +299,6 @@ export async function runWorkerCommand({ projectRoot }) {
     await runPoll("GitHub", "GitHub", state, async () => {
       const repos = filterReposForActiveForge(await listKnownRepos(projectRoot), forgeRegistry);
       const reposByUrl = new Map(repos.map((repo) => [repo.url, repo]));
-      const processedIssues = [];
       let trackedIssueCount = 0;
       const activeClient = forgeRegistry.getActiveClient();
       if (activeClient?.id === "github") {
@@ -302,9 +311,16 @@ export async function runWorkerCommand({ projectRoot }) {
           authorLogin: botUser.login || ""
         });
         trackedIssueCount = issues.length;
+        state.githubIssueCount = trackedIssueCount;
+        state.githubIssues = issues.map(buildQueuedTrackedIssueState);
+        await writeState(runtimePaths.stateFile, state);
         for (const issue of issues) {
+          state.pollerCurrent.github = buildIssueQueueId(issue.repoUrl, issue.number);
+          await writeState(runtimePaths.stateFile, state);
           const repo = reposByUrl.get(issue.repoUrl);
           if (!repo) {
+            reconcileQueueEntry(state.githubIssues, null, (entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(issue.repoUrl, issue.number), () => false);
+            await writeState(runtimePaths.stateFile, state);
             continue;
           }
           const provider = forgeRegistry.getClientForRepo(repo.url);
@@ -325,8 +341,9 @@ export async function runWorkerCommand({ projectRoot }) {
             logger
           });
           if (processed) {
-            processedIssues.push(processed);
+            reconcileQueueEntry(state.githubIssues, processed, (entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(issue.repoUrl, issue.number), () => true);
           }
+          await writeState(runtimePaths.stateFile, state);
         }
       } else if (activeClient?.id === "gitlab") {
         const firstRepoUrl = repos[0]?.url || "";
@@ -339,9 +356,16 @@ export async function runWorkerCommand({ projectRoot }) {
           authorLogin: botUser.login || ""
         });
         trackedIssueCount = issues.length;
+        state.githubIssueCount = trackedIssueCount;
+        state.githubIssues = issues.map(buildQueuedTrackedIssueState);
+        await writeState(runtimePaths.stateFile, state);
         for (const issue of issues) {
+          state.pollerCurrent.github = buildIssueQueueId(issue.repoUrl, issue.number);
+          await writeState(runtimePaths.stateFile, state);
           const repo = reposByUrl.get(issue.repoUrl);
           if (!repo) {
+            reconcileQueueEntry(state.githubIssues, null, (entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(issue.repoUrl, issue.number), () => false);
+            await writeState(runtimePaths.stateFile, state);
             continue;
           }
           const provider = forgeRegistry.getClientForRepo(repo.url);
@@ -362,10 +386,14 @@ export async function runWorkerCommand({ projectRoot }) {
             logger
           });
           if (processed) {
-            processedIssues.push(processed);
+            reconcileQueueEntry(state.githubIssues, processed, (entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(issue.repoUrl, issue.number), () => true);
           }
+          await writeState(runtimePaths.stateFile, state);
         }
       } else {
+        state.githubIssues = [];
+        state.githubIssueCount = 0;
+        await writeState(runtimePaths.stateFile, state);
         for (const repo of repos) {
           const provider = forgeRegistry.getClientForRepo(repo.url);
           const botUser = await getForgeBotUserForRepo(forgeRegistry, forgeBotUsers, repo.url, logger);
@@ -380,7 +408,14 @@ export async function runWorkerCommand({ projectRoot }) {
           });
           const botIssues = issues.filter((issue) => isForgeBotAuthor(issue.author, botUser));
           trackedIssueCount += botIssues.length;
+          state.githubIssueCount = trackedIssueCount;
+          state.githubIssues.push(...botIssues.map(buildQueuedTrackedIssueState).filter((candidate) =>
+            !state.githubIssues.some((entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(candidate.repoUrl, candidate.issueNumber))
+          ));
+          await writeState(runtimePaths.stateFile, state);
           for (const issue of botIssues) {
+            state.pollerCurrent.github = buildIssueQueueId(issue.repoUrl, issue.number);
+            await writeState(runtimePaths.stateFile, state);
             const processed = await processGitHubIssue({
               repo,
               issue,
@@ -393,17 +428,20 @@ export async function runWorkerCommand({ projectRoot }) {
               logger
             });
             if (processed) {
-              processedIssues.push(processed);
+              reconcileQueueEntry(state.githubIssues, processed, (entry) => buildIssueQueueId(entry.repoUrl, entry.issueNumber) === buildIssueQueueId(issue.repoUrl, issue.number), () => true);
             }
+            await writeState(runtimePaths.stateFile, state);
           }
         }
       }
+      state.pollerCurrent.github = "";
       return {
-        stateUpdates: { githubIssueCount: trackedIssueCount, githubIssues: processedIssues.slice(0, 20) },
+        stateUpdates: { githubIssueCount: trackedIssueCount, githubIssues: state.githubIssues },
         logInfo: { tracked: trackedIssueCount }
       };
     }, { stateFile: runtimePaths.stateFile, logger, flagRef: githubFlag });
     state.pollerBusy.github = false;
+    state.pollerCurrent.github = "";
     await writeState(runtimePaths.stateFile, state);
   };
 
@@ -418,7 +456,6 @@ export async function runWorkerCommand({ projectRoot }) {
     await runPoll("Pr", "Pull request", state, async () => {
       const repos = filterReposForActiveForge(await listKnownRepos(projectRoot), forgeRegistry);
       const reposByUrl = new Map(repos.map((repo) => [repo.url, repo]));
-      const processedPrs = [];
       let trackedPrCount = 0;
       const activeClient = forgeRegistry.getActiveClient();
       if (activeClient?.id === "github") {
@@ -431,9 +468,16 @@ export async function runWorkerCommand({ projectRoot }) {
           authorLogin: botUser.login || ""
         });
         trackedPrCount = pullRequests.length;
+        state.draftPrCount = trackedPrCount;
+        state.draftPrs = pullRequests.map(buildQueuedTrackedPullRequestState);
+        await writeState(runtimePaths.stateFile, state);
         for (const pullRequest of pullRequests) {
+          state.pollerCurrent.draftPr = buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number);
+          await writeState(runtimePaths.stateFile, state);
           const repo = reposByUrl.get(pullRequest.repoUrl);
           if (!repo) {
+            reconcileQueueEntry(state.draftPrs, null, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number), () => false);
+            await writeState(runtimePaths.stateFile, state);
             continue;
           }
           const provider = forgeRegistry.getClientForRepo(repo.url);
@@ -456,8 +500,9 @@ export async function runWorkerCommand({ projectRoot }) {
             jiraBotUser
           });
           if (processed) {
-            processedPrs.push(processed);
+            reconcileQueueEntry(state.draftPrs, processed, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number), shouldKeepTrackedPullRequestState);
           }
+          await writeState(runtimePaths.stateFile, state);
         }
       } else if (activeClient?.id === "gitlab") {
         const firstRepoUrl = repos[0]?.url || "";
@@ -470,9 +515,16 @@ export async function runWorkerCommand({ projectRoot }) {
           authorLogin: botUser.login || ""
         });
         trackedPrCount = pullRequests.length;
+        state.draftPrCount = trackedPrCount;
+        state.draftPrs = pullRequests.map(buildQueuedTrackedPullRequestState);
+        await writeState(runtimePaths.stateFile, state);
         for (const pullRequest of pullRequests) {
+          state.pollerCurrent.draftPr = buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number);
+          await writeState(runtimePaths.stateFile, state);
           const repo = reposByUrl.get(pullRequest.repoUrl);
           if (!repo) {
+            reconcileQueueEntry(state.draftPrs, null, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number), () => false);
+            await writeState(runtimePaths.stateFile, state);
             continue;
           }
           const provider = forgeRegistry.getClientForRepo(repo.url);
@@ -495,10 +547,14 @@ export async function runWorkerCommand({ projectRoot }) {
             jiraBotUser
           });
           if (processed) {
-            processedPrs.push(processed);
+            reconcileQueueEntry(state.draftPrs, processed, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number), shouldKeepTrackedPullRequestState);
           }
+          await writeState(runtimePaths.stateFile, state);
         }
       } else {
+        state.draftPrs = [];
+        state.draftPrCount = 0;
+        await writeState(runtimePaths.stateFile, state);
         for (const repo of repos) {
           const provider = forgeRegistry.getClientForRepo(repo.url);
           const botUser = await getForgeBotUserForRepo(forgeRegistry, forgeBotUsers, repo.url, logger);
@@ -515,7 +571,14 @@ export async function runWorkerCommand({ projectRoot }) {
             (pullRequest) => isForgeBotAuthor(pullRequest.author, botUser)
           );
           trackedPrCount += botPullRequests.length;
+          state.draftPrCount = trackedPrCount;
+          state.draftPrs.push(...botPullRequests.map(buildQueuedTrackedPullRequestState).filter((candidate) =>
+            !state.draftPrs.some((entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(candidate.repoUrl, candidate.pullRequestNumber))
+          ));
+          await writeState(runtimePaths.stateFile, state);
           for (const pullRequest of botPullRequests) {
+            state.pollerCurrent.draftPr = buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number);
+            await writeState(runtimePaths.stateFile, state);
             const processed = await processTrackedPullRequest({
               projectRoot,
               runtimePaths,
@@ -530,17 +593,20 @@ export async function runWorkerCommand({ projectRoot }) {
               jiraBotUser
             });
             if (processed) {
-              processedPrs.push(processed);
+              reconcileQueueEntry(state.draftPrs, processed, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pullRequest.repoUrl, pullRequest.number), shouldKeepTrackedPullRequestState);
             }
+            await writeState(runtimePaths.stateFile, state);
           }
         }
       }
+      state.pollerCurrent.draftPr = "";
       return {
-        stateUpdates: { draftPrCount: trackedPrCount, draftPrs: processedPrs.slice(0, 20) },
+        stateUpdates: { draftPrCount: trackedPrCount, draftPrs: state.draftPrs },
         logInfo: { tracked: trackedPrCount }
       };
     }, { stateFile: runtimePaths.stateFile, logger, flagRef: prFlag });
     state.pollerBusy.draftPr = false;
+    state.pollerCurrent.draftPr = "";
     await writeState(runtimePaths.stateFile, state);
   };
 
@@ -558,13 +624,20 @@ export async function runWorkerCommand({ projectRoot }) {
         repoUrls: repos.map((repo) => repo.url)
       });
       let reviewedPrCount = prs.length;
+      state.reviewPrCount = reviewedPrCount;
+      state.reviewPrs = prs.map(buildQueuedReviewPullRequestState);
+      await writeState(runtimePaths.stateFile, state);
       for (const pr of prs) {
+        state.pollerCurrent.reviewPr = buildPullRequestQueueId(pr.repoUrl, pr.number);
+        await writeState(runtimePaths.stateFile, state);
         if (!pr.repoUrl) {
           await logger.error("PR review skipped because repository URL is missing", {
             pr: pr.number,
             title: pr.title
           });
           reviewedPrCount -= 1;
+          reconcileQueueEntry(state.reviewPrs, null, (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pr.repoUrl, pr.number), () => false);
+          await writeState(runtimePaths.stateFile, state);
           continue;
         }
         const provider = forgeRegistry.getClientForRepo(pr.repoUrl);
@@ -579,8 +652,21 @@ export async function runWorkerCommand({ projectRoot }) {
             repoUrl: pr.repoUrl,
             pullRequestNumber: String(pr.number),
             pullRequestUrl: prDetail.url,
+            title: prDetail.title || pr.title || "",
             suggestionsCount: result.suggestions.length
           });
+          reconcileQueueEntry(
+            state.reviewPrs,
+            {
+              repoUrl: pr.repoUrl,
+              pullRequestNumber: String(pr.number),
+              pullRequestUrl: prDetail.url,
+              title: prDetail.title || pr.title || "",
+              suggestionsCount: result.suggestions.length
+            },
+            (entry) => buildPullRequestQueueId(entry.repoUrl, entry.pullRequestNumber) === buildPullRequestQueueId(pr.repoUrl, pr.number),
+            () => true
+          );
           await logger.info("PR review submitted", {
             repo: pr.repoUrl,
             pr: pr.number,
@@ -603,13 +689,16 @@ export async function runWorkerCommand({ projectRoot }) {
             });
           }
         }
+        await writeState(runtimePaths.stateFile, state);
       }
+      state.pollerCurrent.reviewPr = "";
       return {
-        stateUpdates: { reviewPrCount: reviewedPrCount, reviewPrs: processedPrs.slice(0, 20) },
+        stateUpdates: { reviewPrCount: reviewedPrCount, reviewPrs: state.reviewPrs },
         logInfo: { reviewed: reviewedPrCount }
       };
     }, { stateFile: runtimePaths.stateFile, logger, flagRef: reviewFlag });
     state.pollerBusy.reviewPr = false;
+    state.pollerCurrent.reviewPr = "";
     await writeState(runtimePaths.stateFile, state);
   };
 
@@ -3274,6 +3363,125 @@ function buildDefaultIssueMemory(workflowState) {
   };
 }
 
+function buildQueuedJiraIssueState(issue) {
+  const live = deriveJiraLiveState({
+    issue,
+    issueMemory: { github_issues: [] },
+    githubIssues: [],
+    pullRequests: []
+  });
+
+  return {
+    key: issue.key,
+    status: issue.status,
+    labels: normalizeLabels(issue.labels),
+    projectKey: issue.projectKey,
+    workflowState: live.phase,
+    blocker: live.blocker,
+    nextAction: live.nextAction,
+    repoCount: 0,
+    repoUrls: [],
+    localRepoPaths: [],
+    githubIssueUrls: [],
+    claudeDecision: null,
+    lastError: null,
+    sourceOfTruth: live.sourceOfTruth
+  };
+}
+
+function buildQueuedTrackedIssueState(issue) {
+  const live = deriveForgeIssueLiveState({
+    repoUrl: issue.repoUrl,
+    issueNumber: issue.number,
+    issueUrl: issue.url,
+    state: issue.state,
+    labels: issue.labels
+  });
+
+  return {
+    repoUrl: issue.repoUrl,
+    issueNumber: String(issue.number),
+    issueUrl: issue.url,
+    title: issue.title || "",
+    state: issue.state || "",
+    labels: normalizeLabels(issue.labels),
+    workflowState: live.phase,
+    branchName: "",
+    prUrl: "",
+    action: "queued"
+  };
+}
+
+function buildQueuedTrackedPullRequestState(pullRequest) {
+  const repoUrl = String(pullRequest.repoUrl || pullRequest.url || "")
+    .replace(/\/pull\/\d+$/u, "")
+    .replace(/\/-\/merge_requests\/\d+$/u, "");
+  const live = derivePullRequestLiveState({
+    ...pullRequest,
+    repoUrl,
+    pullRequestNumber: pullRequest.number,
+    pullRequestUrl: pullRequest.url,
+    status: getPullRequestStatus(pullRequest.body || "")
+  });
+
+  return {
+    repoUrl,
+    pullRequestNumber: String(pullRequest.number),
+    pullRequestUrl: pullRequest.url,
+    title: pullRequest.title || "",
+    branchName: pullRequest.headRef || "",
+    status: getPullRequestStatus(pullRequest.body || ""),
+    labels: normalizeLabels(pullRequest.labels),
+    workflowState: live.phase,
+    action: "queued"
+  };
+}
+
+function buildQueuedReviewPullRequestState(pullRequest) {
+  return {
+    repoUrl: pullRequest.repoUrl || "",
+    pullRequestNumber: String(pullRequest.number || ""),
+    pullRequestUrl: pullRequest.pullRequestUrl || pullRequest.url || "",
+    title: pullRequest.title || "",
+    suggestionsCount: null
+  };
+}
+
+function buildIssueQueueId(repoUrl, issueNumber) {
+  return `${String(repoUrl || "").trim()}#${String(issueNumber || "").trim()}`;
+}
+
+function buildPullRequestQueueId(repoUrl, pullRequestNumber) {
+  return `${String(repoUrl || "").trim()}!${String(pullRequestNumber || "").trim()}`;
+}
+
+function reconcileQueueEntry(queue, nextValue, matcher, keepPredicate = () => true) {
+  if (!Array.isArray(queue)) {
+    return;
+  }
+
+  const index = queue.findIndex(matcher);
+  const shouldKeep = nextValue && keepPredicate(nextValue);
+
+  if (index === -1) {
+    if (shouldKeep) {
+      queue.push(nextValue);
+    }
+    return;
+  }
+
+  if (!shouldKeep) {
+    queue.splice(index, 1);
+    return;
+  }
+
+  queue[index] = nextValue;
+}
+
+function shouldKeepTrackedPullRequestState(pullRequest) {
+  return String(pullRequest?.workflowState || "").trim() !== "done";
+}
+
 async function fetchLinkedForgeState({ issueMemory, forgeRegistry, logger }) {
   const linkedSource = {
     githubIssues: [],

package/src/dashboard/ui.html

@@ -1947,10 +1947,16 @@ function renderHeartbeatQueues(data) {
   const wrap = document.getElementById("heartbeat-queues-wrap");
   const s = data.state || {};
   const busy = s.pollerBusy || {};
+  const current = s.pollerCurrent || {};
   const forgeRepoName = (url) => {
     try {
       const u = new URL(url || "");
-      const parts = u.pathname.split("/").filter(Boolean);
+      const parts = u.pathname
+        .replace(/\/pull\/\d+$/u, "")
+        .replace(/\/issues\/\d+$/u, "")
+        .replace(/\/-\/merge_requests\/\d+$/u, "")
+        .split("/")
+        .filter(Boolean);
       return parts[parts.length - 1] || "repo";
     } catch {
       return "repo";
@@ -1964,8 +1970,18 @@ function renderHeartbeatQueues(data) {
     { label: "Review PRs", items: s.reviewPrs || [],     busyKey: "reviewPr", type: "pr" }
   ];
 
-  const renderCard = (item, isActive, type, idx) => {
-    const activeClass = isActive && idx === 0 ? " active" : "";
+  const itemQueueId = (item, type) => {
+    if (type === "jira") {
+      return String(item.key || "");
+    }
+    if (type === "github") {
+      return `${String(item.repoUrl || "").trim()}#${String(item.issueNumber || "").trim()}`;
+    }
+    return `${String(item.repoUrl || "").trim()}!${String(item.pullRequestNumber || "").trim()}`;
+  };
+
+  const renderCard = (item, isCurrent, type) => {
+    const activeClass = isCurrent ? " active" : "";
     if (type === "jira") {
       const key = esc(item.key || "");
       const onclick = item.key
@@ -1993,8 +2009,9 @@ function renderHeartbeatQueues(data) {
       <div class="hbq-body">
         ${rows.map(row => {
           const isActive = !!busy[row.busyKey];
+          const currentId = String(current[row.busyKey] || "");
           const cards = row.items.length > 0
-            ? row.items.map((item, idx) => renderCard(item, isActive, row.type, idx)).join("")
+            ? row.items.map((item) => renderCard(item, isActive && itemQueueId(item, row.type) === currentId, row.type)).join("")
             : `<span class="hbq-idle">idle</span>`;
           return `
             <div class="hbq-row">