# 🤖 Gemini Bot: Metrics Integrity & Triage Hygiene

This PR implements several critical improvements to repository health monitoring and automated triage workflows.

### Summary of Changes

1.  **Backlog Age Metric**: Added `tools/gemini-cli-bot/metrics/scripts/backlog_age.ts` to measure the median and P90 age of open issues and PRs. This addresses the "Survivorship Bias" in current latency metrics, which only sample recently closed items.
2.  **Metrics Persistence**: Fixed a bug in `tools/gemini-cli-bot/metrics/index.ts` that limited the timeseries history to 100 lines (effectively ~2 runs). Increased to 5000 lines to preserve historical trends.
3.  **Robust Stale Closer**: Upgraded `.github/workflows/gemini-scheduled-stale-issue-closer.yml` to a 2-phase system (Mark as Stale -> Close). This centralized logic replaces the throttled default stale action and includes robust human activity detection.
4.  **Triage Bug Fix**: Fixed a critical bug in `.github/workflows/unassign-inactive-assignees.yml` where a missing `for` loop caused the script to fail.
5.  **Policy Consolidation**: Disabled issue staleness in `.github/workflows/stale.yml` to avoid conflicts with the new custom 2-phase closer.

### Why this is recommended

- **Data-Driven Triage**: Without backlog age metrics, we were blind to the "Slow Path" backlog that is growing despite fast "recently closed" latency.
- **Automated Hygiene**: The broken and throttled triage workflows were allowing the backlog to grow unchecked (now at 2351 issues). These fixes restore automated pruning.
- **Metrics Reliability**: Expanding the timeseries window ensures that deltas and trends are calculated against stable historical data.

### Impact

- **Backlog Visibility**: New metrics will show the real age of open items.
- **Throughput**: Increased stale closer throughput will begin reducing the 2300+ issue backlog.
- **Reliability**: Automated unassignment of inactive contributors will keep "help wanted" items moving.

.github/workflows/gemini-scheduled-stale-issue-closer.yml

@@ -45,115 +45,141 @@ jobs:
             if (dryRun) {
               core.info('DRY RUN MODE ENABLED: No changes will be applied.');
             }
-            const batchLabel = 'Stale';
+            const staleLabel = 'Stale';
 
-            const threeMonthsAgo = new Date();
-            threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3);
+            const ninetyDaysAgo = new Date();
+            ninetyDaysAgo.setDate(ninetyDaysAgo.getDate() - 90);
 
-            const tenDaysAgo = new Date();
-            tenDaysAgo.setDate(tenDaysAgo.getDate() - 10);
+            const fourteenDaysAgo = new Date();
+            fourteenDaysAgo.setDate(fourteenDaysAgo.getDate() - 14);
 
-            core.info(`Cutoff date for creation: ${threeMonthsAgo.toISOString()}`);
-            core.info(`Cutoff date for updates: ${tenDaysAgo.toISOString()}`);
+            core.info(`Cutoff date for staleness (Phase 1): ${ninetyDaysAgo.toISOString()}`);
+            core.info(`Cutoff date for closure (Phase 2): ${fourteenDaysAgo.toISOString()}`);
 
-            const query = `repo:${context.repo.owner}/${context.repo.repo} is:issue is:open created:<${threeMonthsAgo.toISOString()}`;
-            core.info(`Searching with query: ${query}`);
+            // PHASE 1: Find issues to mark as stale
+            const queryPhase1 = `repo:${context.repo.owner}/${context.repo.repo} is:issue is:open -label:"${staleLabel}" updated:<${ninetyDaysAgo.toISOString()}`;
+            core.info(`Phase 1 Search Query: ${queryPhase1}`);
 
-            const itemsToCheck = await github.paginate(github.rest.search.issuesAndPullRequests, {
-              q: query,
-              sort: 'created',
+            const issuesToStale = await github.paginate(github.rest.search.issuesAndPullRequests, {
+              q: queryPhase1,
+              sort: 'updated',
               order: 'asc',
               per_page: 100
             });
 
-            core.info(`Found ${itemsToCheck.length} open issues to check.`);
+            core.info(`Found ${issuesToStale.length} issues to potentially mark as stale.`);
 
-            let processedCount = 0;
+            // PHASE 2: Find issues to close
+            const queryPhase2 = `repo:${context.repo.owner}/${context.repo.repo} is:issue is:open label:"${staleLabel}" updated:<${fourteenDaysAgo.toISOString()}`;
+            core.info(`Phase 2 Search Query: ${queryPhase2}`);
 
-            for (const issue of itemsToCheck) {
-              const createdAt = new Date(issue.created_at);
-              const updatedAt = new Date(issue.updated_at);
-              const reactionCount = issue.reactions.total_count;
+            const issuesToClose = await github.paginate(github.rest.search.issuesAndPullRequests, {
+              q: queryPhase2,
+              sort: 'updated',
+              order: 'asc',
+              per_page: 100
+            });
 
-              // Basic thresholds
-              if (reactionCount >= 5) {
-                continue;
-              }
+            core.info(`Found ${issuesToClose.length} stale issues to potentially close.`);
 
-              // Skip if it has a maintainer, help wanted, or Public Roadmap label
+            const isMaintainer = (assoc) => ['MEMBER', 'OWNER', 'COLLABORATOR'].includes(assoc);
+
+            async function hasHumanActivity(issueNumber, sinceDate) {
+              const comments = await github.paginate(github.rest.issues.listComments, {
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                per_page: 100
+              });
+
+              return comments.some(comment => 
+                comment.user.type !== 'Bot' && 
+                !comment.user.login.endsWith('[bot]') &&
+                new Date(comment.created_at) > sinceDate
+              );
+            }
+
+            // Execute Phase 1
+            let staleCount = 0;
+            for (const issue of issuesToStale) {
+              if (staleCount >= 100) break; // Limit per run to be safe
+
+              // Skip if it has exempt labels
               const rawLabels = issue.labels.map((l) => l.name);
               const lowercaseLabels = rawLabels.map((l) => l.toLowerCase());
               if (
                 lowercaseLabels.some((l) => l.includes('maintainer')) ||
                 lowercaseLabels.includes('help wanted') ||
+                lowercaseLabels.includes('pinned') ||
+                lowercaseLabels.includes('security') ||
                 rawLabels.includes('🗓️ Public Roadmap')
               ) {
                 continue;
               }
 
-              let isStale = updatedAt < tenDaysAgo;
-
-              // If apparently active, check if it's only bot activity
-              if (!isStale) {
-                try {
-                  const comments = await github.rest.issues.listComments({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: issue.number,
-                    per_page: 100,
-                    sort: 'created',
-                    direction: 'desc'
-                  });
-
-                  const lastHumanComment = comments.data.find(comment => comment.user.type !== 'Bot');
-                  if (lastHumanComment) {
-                    isStale = new Date(lastHumanComment.created_at) < tenDaysAgo;
-                  } else {
-                    // No human comments. Check if creator is human.
-                    if (issue.user.type !== 'Bot') {
-                       isStale = createdAt < tenDaysAgo;
-                    } else {
-                       isStale = true; // Bot created, only bot comments
-                    }
-                  }
-                } catch (error) {
-                  core.warning(`Failed to fetch comments for issue #${issue.number}: ${error.message}`);
-                  continue;
-                }
+              // Double check for human activity (search index might be stale)
+              if (await hasHumanActivity(issue.number, ninetyDaysAgo)) {
+                core.info(`Issue #${issue.number} has recent human activity, skipping Phase 1.`);
+                continue;
               }
 
-              if (isStale) {
-                processedCount++;
-                const message = `Closing stale issue #${issue.number}: "${issue.title}" (${issue.html_url})`;
-                core.info(message);
+              staleCount++;
+              core.info(`Marking #${issue.number} as stale.`);
+              if (!dryRun) {
+                await github.rest.issues.addLabels({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  labels: [staleLabel]
+                });
 
-                if (!dryRun) {
-                  // Add label
-                  await github.rest.issues.addLabels({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: issue.number,
-                    labels: [batchLabel]
-                  });
-
-                  // Add comment
-                  await github.rest.issues.createComment({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: issue.number,
-                    body: 'Hello! As part of our effort to keep our backlog manageable and focus on the most active issues, we are tidying up older reports.\n\nIt looks like this issue hasn\'t been active for a while, so we are closing it for now. However, if you are still experiencing this bug on the latest stable build, please feel free to comment on this issue or create a new one with updated details.\n\nThank you for your contribution!'
-                  });
-
-                  // Close issue
-                  await github.rest.issues.update({
-                    owner: context.repo.owner,
-                    repo: context.repo.repo,
-                    issue_number: issue.number,
-                    state: 'closed',
-                    state_reason: 'not_planned'
-                  });
-                }
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  body: `This issue has been automatically marked as stale because it has not had recent activity. It will be closed in 14 days if no further activity occurs. Thank you for your contributions.`
+                });
               }
             }
 
-            core.info(`\nTotal issues processed: ${processedCount}`);
+            // Execute Phase 2
+            let closeCount = 0;
+            for (const issue of issuesToClose) {
+              if (closeCount >= 100) break; // Limit per run to be safe
+
+              // Double check for human activity since it was marked stale
+              if (await hasHumanActivity(issue.number, fourteenDaysAgo)) {
+                core.info(`Issue #${issue.number} has recent human activity since being marked stale, removing label.`);
+                if (!dryRun) {
+                  await github.rest.issues.removeLabel({
+                    owner: context.repo.owner,
+                    repo: context.repo.repo,
+                    issue_number: issue.number,
+                    name: staleLabel
+                  });
+                }
+                continue;
+              }
+
+              closeCount++;
+              core.info(`Closing stale issue #${issue.number}.`);
+              if (!dryRun) {
+                await github.rest.issues.update({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  state: 'closed',
+                  state_reason: 'not_planned'
+                });
+
+                await github.rest.issues.createComment({
+                  owner: context.repo.owner,
+                  repo: context.repo.repo,
+                  issue_number: issue.number,
+                  body: `This issue has been closed because it has been stale for 14 days with no activity. If you believe this is still relevant, please feel free to comment or reopen the issue. Thank you!`
+                });
+              }
+            }
+
+            core.info(`\nSummary: Marked ${staleCount} as stale, closed ${closeCount}.`);
+

.github/workflows/stale.yml

@@ -26,19 +26,15 @@ jobs:
       - uses: 'actions/stale@5bef64f19d7facfb25b37b414482c7164d639639' # ratchet:actions/stale@v9
         with:
           repo-token: '${{ secrets.GITHUB_TOKEN }}'
-          stale-issue-message: >-
-            This issue has been automatically marked as stale due to 60 days of inactivity.
-            It will be closed in 14 days if no further activity occurs.
+          days-before-issue-stale: -1
+          stale-issue-message: '' 
+          days-before-stale: 60
+          days-before-close: 14
           stale-pr-message: >-
             This pull request has been automatically marked as stale due to 60 days of inactivity.
             It will be closed in 14 days if no further activity occurs.
-          close-issue-message: >-
-            This issue has been closed due to 14 additional days of inactivity after being marked as stale.
-            If you believe this is still relevant, feel free to comment or reopen the issue. Thank you!
           close-pr-message: >-
             This pull request has been closed due to 14 additional days of inactivity after being marked as stale.
             If this is still relevant, you are welcome to reopen or leave a comment. Thanks for contributing!
-          days-before-stale: 60
-          days-before-close: 14
           exempt-issue-labels: 'pinned,security,🔒 maintainer only,help wanted,🗓️ Public Roadmap'
           exempt-pr-labels: 'pinned,security,🔒 maintainer only,help wanted,🗓️ Public Roadmap'

.github/workflows/unassign-inactive-assignees.yml

@@ -145,6 +145,9 @@ jobs:
 
             let totalUnassigned = 0;
 
+            for (const issue of assignedIssues) {
+              core.info(`Checking issue #${issue.number}: "${issue.title}"...`);
+
               let timelineEvents = [];
               try {
                 timelineEvents = await github.paginate(github.rest.issues.listEventsForTimeline, {

tools/gemini-cli-bot/metrics/index.ts

@@ -146,10 +146,10 @@ async function run() {
   if (newRows.length > 0) {
     timeseriesLines.push(...newRows);
 
-    // Keep header + last 100 data rows
-    if (timeseriesLines.length > 101) {
+    // Keep header + last 5000 data rows (enough for ~100 runs of ~50 metrics)
+    if (timeseriesLines.length > 5001) {
       const header = timeseriesLines[0];
-      timeseriesLines = [header, ...timeseriesLines.slice(-100)];
+      timeseriesLines = [header, ...timeseriesLines.slice(-5000)];
     }
 
     writeFileSync(TIMESERIES_FILE, timeseriesLines.join('\n') + '\n');

tools/gemini-cli-bot/metrics/scripts/backlog_age.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { GITHUB_OWNER, GITHUB_REPO } from '../types.js';
+import { execSync } from 'node:child_process';
+
+try {
+  // Query for the 100 oldest open issues and 100 oldest open PRs
+  const query = `
+  query($owner: String!, $repo: String!) {
+    repository(owner: $owner, name: $repo) {
+      issues(first: 100, states: OPEN, orderBy: {field: CREATED_AT, direction: ASC}) {
+        nodes {
+          createdAt
+        }
+      }
+      pullRequests(first: 100, states: OPEN, orderBy: {field: CREATED_AT, direction: ASC}) {
+        nodes {
+          createdAt
+        }
+      }
+    }
+  }
+  `;
+  const output = execSync(
+    `gh api graphql -F owner=${GITHUB_OWNER} -F repo=${GITHUB_REPO} -f query='${query}'`,
+    { encoding: 'utf-8' },
+  );
+  const data = JSON.parse(output).data.repository;
+
+  const now = Date.now();
+
+  const calculateAges = (nodes: { createdAt: string }[]) => {
+    return nodes.map((node) => (now - new Date(node.createdAt).getTime()) / (1000 * 60 * 60 * 24)); // Age in days
+  };
+
+  const issueAges = calculateAges(data.issues.nodes);
+  const prAges = calculateAges(data.pullRequests.nodes);
+
+  const getMedian = (ages: number[]) => {
+    if (ages.length === 0) return 0;
+    const sorted = [...ages].sort((a, b) => a - b);
+    const mid = Math.floor(sorted.length / 2);
+    return sorted.length % 2 !== 0 ? sorted[mid] : (sorted[mid - 1] + sorted[mid]) / 2;
+  };
+
+  const getP90 = (ages: number[]) => {
+    if (ages.length === 0) return 0;
+    const sorted = [...ages].sort((a, b) => a - b);
+    const index = Math.floor(sorted.length * 0.9);
+    return sorted[index];
+  };
+
+  process.stdout.write(`backlog_issue_median_age_days,${Math.round(getMedian(issueAges))}\n`);
+  process.stdout.write(`backlog_issue_p90_age_days,${Math.round(getP90(issueAges))}\n`);
+  process.stdout.write(`backlog_pr_median_age_days,${Math.round(getMedian(prAges))}\n`);
+  process.stdout.write(`backlog_pr_p90_age_days,${Math.round(getP90(prAges))}\n`);
+
+} catch (err) {
+  process.stderr.write(err instanceof Error ? err.message : String(err));
+  process.exit(1);
+}