@oss-autopilot/core 0.53.1 → 0.55.0

package/dist/commands/comments.js

@@ -157,7 +157,6 @@ export async function runClaim(options) {
             updatedAt: new Date().toISOString(),
             vetted: false,
         });
-        stateManager.save();
     }
     catch (error) {
         console.error(`Warning: Comment posted on ${options.issueUrl} but failed to save to local state: ${error instanceof Error ? error.message : error}`);

package/dist/commands/config.js

@@ -3,7 +3,14 @@
  * Shows or updates configuration
  */
 import { getStateManager } from '../core/index.js';
+import { ISSUE_SCOPES } from '../core/types.js';
 import { validateGitHubUsername } from './validation.js';
+function validateScope(value) {
+    if (!ISSUE_SCOPES.includes(value)) {
+        throw new Error(`Invalid scope "${value}". Valid scopes: ${ISSUE_SCOPES.join(', ')}`);
+    }
+    return value;
+}
 export async function runConfig(options) {
     const stateManager = getStateManager();
     const currentConfig = stateManager.getState().config;
@@ -30,6 +37,33 @@ export async function runConfig(options) {
                 stateManager.updateConfig({ labels: [...currentConfig.labels, value] });
             }
             break;
+        case 'remove-label':
+            if (!currentConfig.labels.includes(value)) {
+                throw new Error(`Label "${value}" is not currently configured. Current labels: ${currentConfig.labels.join(', ')}`);
+            }
+            stateManager.updateConfig({ labels: currentConfig.labels.filter((l) => l !== value) });
+            break;
+        case 'add-scope': {
+            const scope = validateScope(value);
+            const currentScopes = currentConfig.scope ?? [];
+            if (!currentScopes.includes(scope)) {
+                stateManager.updateConfig({ scope: [...currentScopes, scope] });
+            }
+            break;
+        }
+        case 'remove-scope': {
+            const scope = validateScope(value);
+            const existingScopes = currentConfig.scope ?? [];
+            if (!existingScopes.includes(scope)) {
+                throw new Error(`Scope "${value}" is not currently set`);
+            }
+            const filtered = existingScopes.filter((s) => s !== scope);
+            if (filtered.length === 0) {
+                throw new Error('Cannot remove the last scope. Use setup to clear scopes entirely.');
+            }
+            stateManager.updateConfig({ scope: filtered });
+            break;
+        }
         case 'exclude-repo': {
             const parts = value.split('/');
             if (parts.length !== 2 || !parts[0] || !parts[1]) {
@@ -37,8 +71,10 @@ export async function runConfig(options) {
             }
             const valueLower = value.toLowerCase();
             if (!currentConfig.excludeRepos.some((r) => r.toLowerCase() === valueLower)) {
-                stateManager.updateConfig({ excludeRepos: [...currentConfig.excludeRepos, value] });
-                stateManager.cleanupExcludedData([value], []);
+                stateManager.batch(() => {
+                    stateManager.updateConfig({ excludeRepos: [...currentConfig.excludeRepos, value] });
+                    stateManager.cleanupExcludedData([value], []);
+                });
             }
             break;
         }
@@ -48,14 +84,18 @@ export async function runConfig(options) {
             }
             const currentOrgs = currentConfig.excludeOrgs ?? [];
             if (!currentOrgs.some((o) => o.toLowerCase() === value.toLowerCase())) {
-                stateManager.updateConfig({ excludeOrgs: [...currentOrgs, value] });
-                stateManager.cleanupExcludedData([], [value]);
+                stateManager.batch(() => {
+                    stateManager.updateConfig({ excludeOrgs: [...currentOrgs, value] });
+                    stateManager.cleanupExcludedData([], [value]);
+                });
             }
             break;
         }
+        case 'issueListPath':
+            stateManager.updateConfig({ issueListPath: value || undefined });
+            break;
         default:
             throw new Error(`Unknown config key: ${options.key}`);
     }
-    stateManager.save();
     return { success: true, key: options.key, value };
 }

package/dist/commands/daily.js

@@ -123,110 +123,124 @@ async function fetchPRData(prMonitor, token) {
  */
 async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     const stateManager = getStateManager();
-    // Reset stale repos first (so excluded/removed repos get zeroed).
-    // Guard: if the API returned zero results but we have existing repos with merged PRs,
-    // skip the reset to avoid wiping scores due to transient API failures.
-    const existingReposWithMerges = Object.values(stateManager.getState().repoScores).filter((s) => s.mergedPRCount > 0);
-    if (mergedCounts.size === 0 && existingReposWithMerges.length > 0) {
-        warn(MODULE, `Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
-    }
-    else {
-        for (const score of Object.values(stateManager.getState().repoScores)) {
-            if (!mergedCounts.has(score.repo)) {
-                stateManager.updateRepoScore(score.repo, { mergedPRCount: 0 });
+    // Batch all synchronous score mutations for a single disk write.
+    // Per-repo try-catch: a single corrupted repo should not prevent updates to others.
+    // Outer try-catch: save failure should not crash the daily check (in-memory mutations still apply).
+    try {
+        stateManager.batch(() => {
+            // Reset stale repos first (so excluded/removed repos get zeroed).
+            // Guard: if the API returned zero results but we have existing repos with merged PRs,
+            // skip the reset to avoid wiping scores due to transient API failures.
+            const existingReposWithMerges = Object.values(stateManager.getState().repoScores).filter((s) => s.mergedPRCount > 0);
+            if (mergedCounts.size === 0 && existingReposWithMerges.length > 0) {
+                warn(MODULE, `Skipping stale repo reset: API returned 0 merged PR results but state has ${existingReposWithMerges.length} repo(s) with merges. Possible API issue.`);
             }
-        }
-    }
-    // Update merged/closed counts with per-repo error isolation (matches signal/trust loops below)
-    let mergedCountFailures = 0;
-    for (const [repo, { count, lastMergedAt }] of mergedCounts) {
-        try {
-            stateManager.updateRepoScore(repo, { mergedPRCount: count, lastMergedAt: lastMergedAt || undefined });
-        }
-        catch (error) {
-            mergedCountFailures++;
-            warn(MODULE, `Failed to update merged count for ${repo}: ${errorMessage(error)}`);
-        }
-    }
-    if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
-        warn(MODULE, `[ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
-    }
-    // Populate closedWithoutMergeCount in repo scores.
-    // Diagnostic: warn if API returned empty but we have known closed PRs (possible transient API failure).
-    // Unlike merged counts above, there is no stale-reset loop for closed counts, so no skip is needed.
-    const existingReposWithClosed = Object.values(stateManager.getState().repoScores).filter((s) => (s.closedWithoutMergeCount || 0) > 0);
-    if (closedCounts.size === 0 && existingReposWithClosed.length > 0) {
-        warn(MODULE, `API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
-    }
-    let closedCountFailures = 0;
-    for (const [repo, count] of closedCounts) {
-        try {
-            stateManager.updateRepoScore(repo, { closedWithoutMergeCount: count });
-        }
-        catch (error) {
-            closedCountFailures++;
-            warn(MODULE, `Failed to update closed count for ${repo}: ${errorMessage(error)}`);
-        }
-    }
-    if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
-        warn(MODULE, `[ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
-    }
-    // Update repo signals from observed open PR data (responsiveness, active maintainers).
-    // Only repos with current open PRs get signal updates — repos with no open PRs
-    // preserve their existing signals to avoid degrading scores when PRs are merged.
-    // Per-repo try-catch: signal/trust syncing is secondary to the daily digest —
-    // a single corrupted repo score should not prevent updates to other repos.
-    const repoSignals = computeRepoSignals(prs);
-    let signalUpdateFailures = 0;
-    for (const [repo, signals] of repoSignals) {
-        try {
-            stateManager.updateRepoScore(repo, { signals });
-        }
-        catch (error) {
-            signalUpdateFailures++;
-            warn(MODULE, `Failed to update signals for ${repo}: ${errorMessage(error)}`);
-        }
+            else {
+                for (const score of Object.values(stateManager.getState().repoScores)) {
+                    if (!mergedCounts.has(score.repo)) {
+                        stateManager.updateRepoScore(score.repo, { mergedPRCount: 0 });
+                    }
+                }
+            }
+            // Update merged/closed counts
+            let mergedCountFailures = 0;
+            for (const [repo, { count, lastMergedAt }] of mergedCounts) {
+                try {
+                    stateManager.updateRepoScore(repo, { mergedPRCount: count, lastMergedAt: lastMergedAt || undefined });
+                }
+                catch (error) {
+                    mergedCountFailures++;
+                    warn(MODULE, `Failed to update merged count for ${repo}: ${errorMessage(error)}`);
+                }
+            }
+            if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
+                warn(MODULE, `[ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
+            }
+            // Populate closedWithoutMergeCount in repo scores.
+            const existingReposWithClosed = Object.values(stateManager.getState().repoScores).filter((s) => (s.closedWithoutMergeCount || 0) > 0);
+            if (closedCounts.size === 0 && existingReposWithClosed.length > 0) {
+                warn(MODULE, `API returned 0 closed PR results but state has ${existingReposWithClosed.length} repo(s) with closed PRs. Possible transient API issue.`);
+            }
+            let closedCountFailures = 0;
+            for (const [repo, count] of closedCounts) {
+                try {
+                    stateManager.updateRepoScore(repo, { closedWithoutMergeCount: count });
+                }
+                catch (error) {
+                    closedCountFailures++;
+                    warn(MODULE, `Failed to update closed count for ${repo}: ${errorMessage(error)}`);
+                }
+            }
+            if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
+                warn(MODULE, `[ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
+            }
+            // Update repo signals from observed open PR data
+            const repoSignals = computeRepoSignals(prs);
+            let signalUpdateFailures = 0;
+            for (const [repo, signals] of repoSignals) {
+                try {
+                    stateManager.updateRepoScore(repo, { signals });
+                }
+                catch (error) {
+                    signalUpdateFailures++;
+                    warn(MODULE, `Failed to update signals for ${repo}: ${errorMessage(error)}`);
+                }
+            }
+            if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
+                warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+            }
+        });
     }
-    if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
-        warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+    catch (error) {
+        warn(MODULE, `Failed to persist repo score updates: ${errorMessage(error)}`);
     }
-    // Fetch star counts for all scored repos (used by dashboard minStars filter, #216)
+    // Fetch metadata (stars + language) for all scored repos — async, so outside the batch above
     const allRepos = Object.keys(stateManager.getState().repoScores);
-    let starCounts;
+    let repoMetadata;
     try {
-        starCounts = await prMonitor.fetchRepoStarCounts(allRepos);
+        repoMetadata = await prMonitor.fetchRepoMetadata(allRepos);
     }
     catch (error) {
-        warn(MODULE, `Failed to fetch repo star counts: ${errorMessage(error)}`);
-        warn(MODULE, 'Repos without cached star data will be excluded from stats until star counts are fetched on the next successful run.');
-        starCounts = new Map();
+        if (isRateLimitOrAuthError(error))
+            throw error;
+        warn(MODULE, `Failed to fetch repo metadata: ${errorMessage(error)}`);
+        warn(MODULE, 'Repos without cached metadata will be excluded from dashboard stats and metadata badges until fetched on the next successful run.');
+        repoMetadata = new Map();
     }
-    let starUpdateFailures = 0;
-    for (const [repo, stars] of starCounts) {
-        try {
-            stateManager.updateRepoScore(repo, { stargazersCount: stars });
-        }
-        catch (error) {
-            starUpdateFailures++;
-            warn(MODULE, `Failed to update star count for ${repo}: ${errorMessage(error)}`);
-        }
-    }
-    if (starUpdateFailures === starCounts.size && starCounts.size > 0) {
-        warn(MODULE, `[ALL_STAR_COUNT_UPDATES_FAILED] All ${starCounts.size} star count update(s) failed.`);
-    }
-    // Auto-sync trustedProjects from repos with merged PRs
-    let trustSyncFailures = 0;
-    for (const [repo] of mergedCounts) {
-        try {
-            stateManager.addTrustedProject(repo);
-        }
-        catch (error) {
-            trustSyncFailures++;
-            warn(MODULE, `Failed to sync trusted project ${repo}: ${errorMessage(error)}`);
-        }
+    // Batch metadata + trust sync mutations for a single disk write
+    try {
+        stateManager.batch(() => {
+            let metadataUpdateFailures = 0;
+            for (const [repo, { stars, language }] of repoMetadata) {
+                try {
+                    stateManager.updateRepoScore(repo, { stargazersCount: stars, language });
+                }
+                catch (error) {
+                    metadataUpdateFailures++;
+                    warn(MODULE, `Failed to update metadata for ${repo}: ${errorMessage(error)}`);
+                }
+            }
+            if (metadataUpdateFailures === repoMetadata.size && repoMetadata.size > 0) {
+                warn(MODULE, `[ALL_METADATA_UPDATES_FAILED] All ${repoMetadata.size} metadata update(s) failed.`);
+            }
+            // Auto-sync trustedProjects from repos with merged PRs
+            let trustSyncFailures = 0;
+            for (const [repo] of mergedCounts) {
+                try {
+                    stateManager.addTrustedProject(repo);
+                }
+                catch (error) {
+                    trustSyncFailures++;
+                    warn(MODULE, `Failed to sync trusted project ${repo}: ${errorMessage(error)}`);
+                }
+            }
+            if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
+                warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+            }
+        });
     }
-    if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
-        warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+    catch (error) {
+        warn(MODULE, `Failed to persist metadata/trust updates: ${errorMessage(error)}`);
     }
 }
 /**
@@ -244,38 +258,47 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
     const shelvedPRs = [];
     const autoUnshelvedPRs = [];
     const activePRs = [];
-    for (const pr of overriddenPRs) {
-        if (stateManager.isPRShelved(pr.url)) {
-            if (CRITICAL_STATUSES.has(pr.status)) {
-                stateManager.unshelvePR(pr.url);
-                autoUnshelvedPRs.push(toShelvedPRRef(pr));
-                activePRs.push(pr);
-            }
-            else {
-                shelvedPRs.push(toShelvedPRRef(pr));
+    // Wrap mutations in batch: unshelvePR calls + setLastDigest produce a single save.
+    // Outer try-catch: save failure should not crash the daily check (in-memory mutations still apply).
+    try {
+        stateManager.batch(() => {
+            for (const pr of overriddenPRs) {
+                if (stateManager.isPRShelved(pr.url)) {
+                    if (CRITICAL_STATUSES.has(pr.status)) {
+                        stateManager.unshelvePR(pr.url);
+                        autoUnshelvedPRs.push(toShelvedPRRef(pr));
+                        activePRs.push(pr);
+                    }
+                    else {
+                        shelvedPRs.push(toShelvedPRRef(pr));
+                    }
+                }
+                else if (pr.stalenessTier === 'dormant' && !CRITICAL_STATUSES.has(pr.status)) {
+                    // Dormant PRs are auto-shelved unless they need addressing
+                    // (e.g. maintainer commented on a stale PR — it should resurface)
+                    shelvedPRs.push(toShelvedPRRef(pr));
+                }
+                else {
+                    activePRs.push(pr);
+                }
             }
-        }
-        else if (pr.stalenessTier === 'dormant' && !CRITICAL_STATUSES.has(pr.status)) {
-            // Dormant PRs are auto-shelved unless they need addressing
-            // (e.g. maintainer commented on a stale PR — it should resurface)
-            shelvedPRs.push(toShelvedPRRef(pr));
-        }
-        else {
-            activePRs.push(pr);
-        }
+            // Generate digest from override-applied PRs so status categories are correct.
+            // Note: digest.openPRs contains ALL fetched PRs (including shelved).
+            // We override summary fields below to reflect active-only counts.
+            const digest = prMonitor.generateDigest(overriddenPRs, recentlyClosedPRs, recentlyMergedPRs);
+            // Attach shelve info to digest
+            digest.shelvedPRs = shelvedPRs;
+            digest.autoUnshelvedPRs = autoUnshelvedPRs;
+            digest.summary.totalActivePRs = activePRs.length;
+            // Store digest in state so dashboard can render it
+            stateManager.setLastDigest(digest);
+        });
+    }
+    catch (error) {
+        warn(MODULE, `Failed to persist partition state: ${errorMessage(error)}`);
     }
-    // Generate digest from override-applied PRs so status categories are correct.
-    // Note: digest.openPRs contains ALL fetched PRs (including shelved).
-    // We override summary fields below to reflect active-only counts.
-    const digest = prMonitor.generateDigest(overriddenPRs, recentlyClosedPRs, recentlyMergedPRs);
-    // Attach shelve info to digest
-    digest.shelvedPRs = shelvedPRs;
-    digest.autoUnshelvedPRs = autoUnshelvedPRs;
-    digest.summary.totalActivePRs = activePRs.length;
-    // Store digest in state so dashboard can render it
-    stateManager.setLastDigest(digest);
-    // Save state (updates lastRunAt, lastDigest, and any auto-unshelve changes)
-    stateManager.save();
+    // Digest was created inside batch — reconstruct from state
+    const digest = stateManager.getState().lastDigest;
     return { activePRs, shelvedPRs, autoUnshelvedPRs, digest };
 }
 /**
@@ -287,43 +310,47 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
     const stateManager = getStateManager();
     // Assess capacity from active PRs only (shelved PRs excluded)
     const capacity = assessCapacity(activePRs, stateManager.getState().config.maxActivePRs, shelvedPRs.length);
-    // Filter dismissed issues: suppress if dismissed after last response, resurface + auto-undismiss if new activity
-    let hasAutoUndismissed = false;
-    const filteredCommentedIssues = commentedIssues.filter((issue) => {
-        const dismissedAt = stateManager.getIssueDismissedAt(issue.url);
-        if (!dismissedAt)
-            return true; // Not dismissed — include
-        if (issue.status === 'new_response') {
-            const responseTime = new Date(issue.lastResponseAt).getTime();
-            const dismissTime = new Date(dismissedAt).getTime();
-            if (isNaN(responseTime) || isNaN(dismissTime)) {
-                // Invalid timestamp — fail open (include issue to be safe) without
-                // permanently removing dismiss record (may be a transient data issue)
-                warn(MODULE, `Invalid timestamp in dismiss check for ${issue.url}, including issue`);
-                return true;
-            }
-            if (responseTime > dismissTime) {
-                // New activity after dismiss — auto-undismiss and resurface
-                warn(MODULE, `Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
-                stateManager.undismissIssue(issue.url);
-                hasAutoUndismissed = true;
-                return true;
-            }
-        }
-        // Still dismissed (last response is at or before dismiss timestamp)
-        return false;
-    });
+    // Filter dismissed issues: suppress if dismissed after last response, resurface + auto-undismiss if new activity.
+    // Batch: undismissIssue calls trigger autoSave — batch produces a single disk write for all auto-undismisses.
+    let filteredCommentedIssues = [];
+    try {
+        stateManager.batch(() => {
+            filteredCommentedIssues = commentedIssues.filter((issue) => {
+                const dismissedAt = stateManager.getIssueDismissedAt(issue.url);
+                if (!dismissedAt)
+                    return true; // Not dismissed — include
+                if (issue.status === 'new_response') {
+                    const responseTime = new Date(issue.lastResponseAt).getTime();
+                    const dismissTime = new Date(dismissedAt).getTime();
+                    if (isNaN(responseTime) || isNaN(dismissTime)) {
+                        // Invalid timestamp — fail open (include issue to be safe) without
+                        // permanently removing dismiss record (may be a transient data issue)
+                        warn(MODULE, `Invalid timestamp in dismiss check for ${issue.url}, including issue`);
+                        return true;
+                    }
+                    if (responseTime > dismissTime) {
+                        // New activity after dismiss — auto-undismiss and resurface
+                        warn(MODULE, `Auto-undismissing issue ${issue.url}: new response at ${issue.lastResponseAt} after dismiss at ${dismissedAt}`);
+                        try {
+                            stateManager.undismissIssue(issue.url);
+                        }
+                        catch (error) {
+                            warn(MODULE, `Failed to persist auto-undismiss for ${issue.url}: ${errorMessage(error)}`);
+                        }
+                        return true;
+                    }
+                }
+                // Still dismissed (last response is at or before dismiss timestamp)
+                return false;
+            });
+        });
+    }
+    catch (error) {
+        warn(MODULE, `Failed to persist auto-undismiss state: ${errorMessage(error)}`);
+    }
     const issueResponses = filteredCommentedIssues.filter((i) => i.status === 'new_response');
     const summary = formatSummary(digest, capacity, issueResponses);
-    // Persist auto-undismiss state changes for issues
-    if (hasAutoUndismissed) {
-        try {
-            stateManager.save();
-        }
-        catch (error) {
-            warn(MODULE, `Failed to persist auto-undismissed state: ${errorMessage(error)}`);
-        }
-    }
+    // Auto-undismiss mutations are auto-saved by undismissIssue()
     const actionableIssues = collectActionableIssues(activePRs, previousLastDigestAt);
     digest.summary.totalNeedingAttention = actionableIssues.length;
     const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length);
@@ -390,8 +417,16 @@ async function executeDailyCheckInternal(token) {
     const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token);
     // Phase 2: Update repo scores (signals, star counts, trust sync)
     await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
-    // Phase 3: Persist monthly analytics
-    updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+    // Phase 3: Persist monthly analytics (batch the 3 monthly setter calls).
+    // try-catch: analytics are supplementary — save failure should not crash the daily check.
+    try {
+        getStateManager().batch(() => {
+            updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+        });
+    }
+    catch (error) {
+        warn(MODULE, `Failed to persist monthly analytics: ${errorMessage(error)}`);
+    }
     // Capture lastDigestAt BEFORE Phase 4 overwrites it with the current run's timestamp.
     // Used by collectActionableIssues to determine which PRs are "new" (created since last digest).
     const previousLastDigestAt = getStateManager().getState().lastDigestAt;

package/dist/commands/dashboard-data.js

@@ -169,43 +169,50 @@ export async function fetchDashboardData(token) {
     if (failures.length > 0) {
         warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
-    // Store new merged PRs incrementally (dedupes by URL)
+    // Wrap all state mutations in a batch for a single disk write.
+    // try-catch: save errors should not crash the dashboard data fetch.
     try {
-        stateManager.addMergedPRs(newMergedPRs);
-    }
-    catch (error) {
-        warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
-    }
-    // Store new closed PRs incrementally (dedupes by URL)
-    try {
-        stateManager.addClosedPRs(newClosedPRs);
+        stateManager.batch(() => {
+            // Store new merged PRs incrementally (dedupes by URL)
+            try {
+                stateManager.addMergedPRs(newMergedPRs);
+            }
+            catch (error) {
+                warn(MODULE, `Failed to store merged PRs: ${errorMessage(error)}`);
+            }
+            // Store new closed PRs incrementally (dedupes by URL)
+            try {
+                stateManager.addClosedPRs(newClosedPRs);
+            }
+            catch (error) {
+                warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);
+            }
+            // Store monthly chart data (opened/merged/closed) so charts have data
+            const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
+            const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
+            updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+            const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
+            // Apply shelve partitioning for display (auto-unshelve only runs in daily check)
+            // Dormant PRs are treated as shelved unless they need addressing
+            const shelvedUrls = new Set(stateManager.getState().config.shelvedPRUrls || []);
+            const freshShelved = prs.filter((pr) => shelvedUrls.has(pr.url) || (pr.stalenessTier === 'dormant' && pr.status !== 'needs_addressing'));
+            digest.shelvedPRs = freshShelved.map(toShelvedPRRef);
+            digest.autoUnshelvedPRs = [];
+            digest.summary.totalActivePRs = prs.length - freshShelved.length;
+            stateManager.setLastDigest(digest);
+        });
     }
     catch (error) {
-        warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);
+        warn(MODULE, `Failed to persist dashboard state: ${errorMessage(error)}`);
     }
-    // Convert stored PRs to full types (derive repo/number from URL)
+    warn(MODULE, `Refreshed: ${prs.length} PRs fetched`);
+    // Convert stored PRs to full types (derive repo/number from URL) — read-only, outside batch
     const allMergedPRs = storedToMergedPRs(stateManager.getMergedPRs());
     const allClosedPRs = storedToClosedPRs(stateManager.getClosedPRs());
-    // Store monthly chart data (opened/merged/closed) so charts have data
-    const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
-    const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
-    updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
-    const digest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
-    // Apply shelve partitioning for display (auto-unshelve only runs in daily check)
-    // Dormant PRs are treated as shelved unless they need addressing
-    const shelvedUrls = new Set(stateManager.getState().config.shelvedPRUrls || []);
-    const freshShelved = prs.filter((pr) => shelvedUrls.has(pr.url) || (pr.stalenessTier === 'dormant' && pr.status !== 'needs_addressing'));
-    digest.shelvedPRs = freshShelved.map(toShelvedPRRef);
-    digest.autoUnshelvedPRs = [];
-    digest.summary.totalActivePRs = prs.length - freshShelved.length;
-    stateManager.setLastDigest(digest);
-    try {
-        stateManager.save();
+    const digest = stateManager.getState().lastDigest;
+    if (!digest) {
+        throw new Error('Dashboard data fetch failed: digest was not generated');
     }
-    catch (error) {
-        warn(MODULE, `Failed to save dashboard digest to state: ${errorMessage(error)}`);
-    }
-    warn(MODULE, `Refreshed: ${prs.length} PRs fetched`);
     return { digest, commentedIssues, allMergedPRs, allClosedPRs };
 }
 /**

package/dist/commands/dashboard-server.js

@@ -53,6 +53,13 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
     const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
     const dismissedIssues = state.config.dismissedIssues || {};
     const issueResponses = commentedIssues.filter((i) => i.status === 'new_response' && !(i.url in dismissedIssues));
+    // Build repo metadata map from repoScores — omit repos without stars or language to avoid empty entries
+    const repoMetadata = {};
+    for (const [repo, score] of Object.entries(repoScores)) {
+        if (score.stargazersCount !== undefined || score.language !== undefined) {
+            repoMetadata[repo] = { stars: score.stargazersCount, language: score.language };
+        }
+    }
     return {
         stats,
         prsByRepo,
@@ -69,6 +76,7 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
         issueResponses,
         allMergedPRs: filteredMergedPRs,
         allClosedPRs: filteredClosedPRs,
+        repoMetadata,
     };
 }
 /**
@@ -285,7 +293,6 @@ export async function startDashboardServer(options) {
             else {
                 // dismiss_issue_response
                 stateManager.dismissIssue(body.url, new Date().toISOString());
-                stateManager.save();
             }
         }
         catch (error) {

package/dist/commands/dismiss.js

@@ -10,9 +10,6 @@ export async function runDismiss(options) {
     validateGitHubUrl(options.url, ISSUE_URL_PATTERN, 'issue');
     const stateManager = getStateManager();
     const added = stateManager.dismissIssue(options.url, new Date().toISOString());
-    if (added) {
-        stateManager.save();
-    }
     return { dismissed: added, url: options.url };
 }
 export async function runUndismiss(options) {
@@ -20,8 +17,5 @@ export async function runUndismiss(options) {
     validateGitHubUrl(options.url, ISSUE_URL_PATTERN, 'issue');
     const stateManager = getStateManager();
     const removed = stateManager.undismissIssue(options.url);
-    if (removed) {
-        stateManager.save();
-    }
     return { undismissed: removed, url: options.url };
 }