@oss-autopilot/core 3.13.4 → 3.14.1

package/dist/commands/daily.js

@@ -6,15 +6,15 @@
  * Domain logic lives in src/core/daily-logic.ts; this file is a thin
  * orchestration layer that wires up the phases and handles I/O.
  */
-import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, summarizeAttentionBuckets, } from '../core/index.js';
+import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, renderGistWarning, CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, summarizeAttentionBuckets, } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { wrapUntrustedContent } from '../core/untrusted-content.js';
 import { computeStrategy, shouldComputeStrategy } from '../core/strategy.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
-import { createAutopilotScout } from './scout-bridge.js';
 import { updateMonthlyAnalytics } from './dashboard-data.js';
 import { deduplicateDigest, compactActionableIssues, compactRepoGroups, buildStalenessWarning, } from '../formatters/json.js';
+import { reconcileMergedPRsWithList } from './merge-loop.js';
 const MODULE = 'daily';
 /**
  * Record a non-fatal failure: push a structured entry into the run's warnings
@@ -45,7 +45,7 @@ export { applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacit
 // reuse it without crossing the commands → sibling-command boundary
 // (#1208 M7). Re-exported here for backward compatibility with anyone
 // importing from this module.
-import { buildStarFilter } from '../core/daily-logic.js';
+import { buildStarFilter, firstMaintainerResponseFromDigest } from '../core/daily-logic.js';
 export { buildStarFilter };
 // ---------------------------------------------------------------------------
 // Phase functions
@@ -192,16 +192,17 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warn
                     warn(MODULE, `Failed to update merged count for ${repo}: ${errorMessage(error)}`);
                 }
             }
-            if (mergedCountFailures === mergedCounts.size && mergedCounts.size > 0) {
-                // Total failure: batch outer-catch sees nothing because the batch itself
-                // succeeded, but every individual mutation inside threw. State may be
-                // silently stale — surface it as a warning distinct from the outer catch.
+            if (mergedCountFailures > 0) {
+                // Partial or total failure (#1448): the batch outer-catch sees nothing
+                // because the batch itself succeeded, but individual mutations inside
+                // threw. The affected repos' scores are silently stale — surface it as
+                // a warning distinct from the outer catch.
                 warnings.push({
                     phase: 'repo-scores',
                     operation: 'update merged counts',
-                    message: `All ${mergedCounts.size} merged count update(s) failed. This may indicate corrupted state.`,
+                    message: `${mergedCountFailures} of ${mergedCounts.size} merged count update(s) failed. This may indicate corrupted state.`,
                 });
-                warn(MODULE, `[ALL_MERGED_COUNT_UPDATES_FAILED] All ${mergedCounts.size} merged count update(s) failed.`);
+                warn(MODULE, `[MERGED_COUNT_UPDATES_FAILED] ${mergedCountFailures} of ${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);
@@ -218,13 +219,13 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warn
                     warn(MODULE, `Failed to update closed count for ${repo}: ${errorMessage(error)}`);
                 }
             }
-            if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
+            if (closedCountFailures > 0) {
                 warnings.push({
                     phase: 'repo-scores',
                     operation: 'update closed counts',
-                    message: `All ${closedCounts.size} closed count update(s) failed. This may indicate corrupted state.`,
+                    message: `${closedCountFailures} of ${closedCounts.size} closed count update(s) failed. This may indicate corrupted state.`,
                 });
-                warn(MODULE, `[ALL_CLOSED_COUNT_UPDATES_FAILED] All ${closedCounts.size} closed count update(s) failed.`);
+                warn(MODULE, `[CLOSED_COUNT_UPDATES_FAILED] ${closedCountFailures} of ${closedCounts.size} closed count update(s) failed.`);
             }
             // Update repo signals from observed open PR data
             const repoSignals = computeRepoSignals(prs);
@@ -238,13 +239,13 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warn
                     warn(MODULE, `Failed to update signals for ${repo}: ${errorMessage(error)}`);
                 }
             }
-            if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
+            if (signalUpdateFailures > 0) {
                 warnings.push({
                     phase: 'repo-scores',
                     operation: 'update repo signals',
-                    message: `All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`,
+                    message: `${signalUpdateFailures} of ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`,
                 });
-                warn(MODULE, `[ALL_SIGNAL_UPDATES_FAILED] All ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
+                warn(MODULE, `[SIGNAL_UPDATES_FAILED] ${signalUpdateFailures} of ${repoSignals.size} signal update(s) failed. This may indicate corrupted state.`);
             }
         });
     }
@@ -277,13 +278,13 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warn
                     warn(MODULE, `Failed to update metadata for ${repo}: ${errorMessage(error)}`);
                 }
             }
-            if (metadataUpdateFailures === repoMetadata.size && repoMetadata.size > 0) {
+            if (metadataUpdateFailures > 0) {
                 warnings.push({
                     phase: 'repo-scores',
                     operation: 'update repo metadata',
-                    message: `All ${repoMetadata.size} metadata update(s) failed. This may indicate corrupted state.`,
+                    message: `${metadataUpdateFailures} of ${repoMetadata.size} metadata update(s) failed. This may indicate corrupted state.`,
                 });
-                warn(MODULE, `[ALL_METADATA_UPDATES_FAILED] All ${repoMetadata.size} metadata update(s) failed.`);
+                warn(MODULE, `[METADATA_UPDATES_FAILED] ${metadataUpdateFailures} of ${repoMetadata.size} metadata update(s) failed.`);
             }
             // Auto-sync trustedProjects from repos with merged PRs
             let trustSyncFailures = 0;
@@ -296,13 +297,13 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warn
                     warn(MODULE, `Failed to sync trusted project ${repo}: ${errorMessage(error)}`);
                 }
             }
-            if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
+            if (trustSyncFailures > 0) {
                 warnings.push({
                     phase: 'repo-scores',
                     operation: 'sync trusted projects',
-                    message: `All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`,
+                    message: `${trustSyncFailures} of ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`,
                 });
-                warn(MODULE, `[ALL_TRUST_SYNCS_FAILED] All ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
+                warn(MODULE, `[TRUST_SYNCS_FAILED] ${trustSyncFailures} of ${mergedCounts.size} trusted project sync(s) failed. This may indicate corrupted state.`);
             }
         });
     }
@@ -320,13 +321,20 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs, warn
     // Apply dashboard/CLI status overrides before partitioning.
     // This ensures PRs reclassified in the dashboard (e.g., "Need Attention" → "Waiting")
     // are respected by the CLI pipeline.
-    const overriddenPRs = applyStatusOverrides(prs, stateManager.getState());
+    // Override-application failures (#1448) mean a PR silently shows its
+    // un-overridden status — record each into the run's warnings[].
+    const overrideFailures = [];
+    const overriddenPRs = applyStatusOverrides(prs, stateManager.getState(), overrideFailures);
+    for (const failure of overrideFailures) {
+        recordWarning(warnings, 'partition', 'apply status override', null, failure);
+    }
     // Partition PRs into active vs shelved, auto-unshelving when maintainers engage
     const shelvedPRs = [];
     const autoUnshelvedPRs = [];
     const activePRs = [];
     // 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).
+    let digest;
     try {
         stateManager.batch(() => {
             for (const pr of overriddenPRs) {
@@ -349,23 +357,49 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs, warn
                     activePRs.push(pr);
                 }
             }
-            // Generate digest from override-applied PRs so status categories are correct.
+            // Generate the in-memory digest from override-applied PRs so daily's own
+            // status categories (needsAddressing/waiting partitions, counts, JSON
+            // output) reflect dashboard/CLI reclassifications.
             // 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);
+            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);
+            // The PERSISTED digest keeps RAW statuses (#1445): it seeds the
+            // dashboard server's cached rebuild source, and applyStatusOverrides
+            // can only apply overrides, never un-apply baked ones — persisting the
+            // override-applied digest would make CLEARING an override (move
+            // target=auto) a silent no-op whenever the dashboard's background
+            // refresh fails. Mirrors the raw-digest contract in dashboard-data.ts
+            // (which also attaches override-derived shelve info to a raw digest).
+            const rawDigest = prMonitor.generateDigest(prs, recentlyClosedPRs, recentlyMergedPRs);
+            rawDigest.shelvedPRs = shelvedPRs;
+            rawDigest.autoUnshelvedPRs = autoUnshelvedPRs;
+            rawDigest.summary.totalActivePRs = activePRs.length;
+            stateManager.setLastDigest(rawDigest);
         });
     }
     catch (error) {
         recordWarning(warnings, 'partition', 'persist partition state', error);
     }
-    // Digest was created inside batch — reconstruct from state
-    const digest = stateManager.getState().lastDigest;
+    // If digest generation threw inside the batch, fall back to the persisted
+    // digest (mirrors the previous read-back-from-state behavior). The
+    // recordWarning call above already flagged the run as degraded.
+    if (digest === undefined) {
+        const persisted = stateManager.getState().lastDigest;
+        if (!persisted) {
+            // First-ever run with no persisted digest to fall back to: fail loudly
+            // with the recorded reason instead of letting Phase 5 die on an
+            // unrelated TypeError at `digest.summary` (#1456). Fabricating an
+            // empty digest here would silently report "no PRs" — dishonest.
+            const recorded = warnings.find((w) => w.phase === 'partition');
+            throw new Error(`Daily digest generation failed and no previously persisted digest exists to fall back to` +
+                (recorded ? `: ${recorded.message}` : '.'));
+        }
+        return { activePRs, shelvedPRs, autoUnshelvedPRs, digest: persisted };
+    }
     return { activePRs, shelvedPRs, autoUnshelvedPRs, digest };
 }
 /**
@@ -373,7 +407,7 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs, warn
  * Assesses capacity, filters dismissed issues, computes actionable items,
  * and assembles the action menu.
  */
-function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt) {
+function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt, unextractedMergeCount) {
     const stateManager = getStateManager();
     // Assess capacity from active PRs only (shelved PRs excluded)
     const capacity = assessCapacity(activePRs, stateManager.getState().config.maxActivePRs, shelvedPRs.length);
@@ -424,7 +458,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
     // the same buckets per-PR, so the headline counts cannot diverge.
     const attention = summarizeAttentionBuckets(activePRs);
     const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length, attention);
-    const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues);
+    const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues, attention, unextractedMergeCount);
     const repoGroups = groupPRsByRepo(activePRs);
     // Periodic strategy snapshot (#1270 Step 2). Cadence-gated to fire every
     // 30 days OR after 5+ PRs merge since the last snapshot, whichever comes
@@ -513,6 +547,9 @@ export function toDailyOutput(result) {
         failures: result.failures,
         warnings: result.warnings,
         strategySummary: result.strategySummary,
+        // Conditional spread (not a plain assignment) so merge-free runs carry
+        // no `listUpdates` key at all — serialized output and goldens unchanged.
+        ...(result.listUpdates ? { listUpdates: result.listUpdates } : {}),
     };
 }
 /**
@@ -547,13 +584,15 @@ async function executeDailyCheckInternal(token) {
     // callgraph documents which phases can produce non-fatal warnings. See #1042.
     const warnings = [];
     // Surface gist-mode degradation in the machine-readable envelope (#1431):
-    // a process whose config says `persistence: gist` but whose manager is
-    // local-only (transient init fallback, or a localOnly entry point that
-    // never bootstrapped) writes mutations that will not sync. Previously the
-    // only signal was a stderr warn, invisible to --json consumers.
-    const smForGistCheck = getStateManager();
-    if (smForGistCheck.getState().config.persistence === 'gist' && !smForGistCheck.isGistMode()) {
-        recordWarning(warnings, 'gist-init', 'Gist persistence degraded', new Error('configured for Gist but running local-only in this process; mutations will not sync until Gist init succeeds'));
+    // a degraded process (local-only under a gist config, or a #1443 degraded
+    // bootstrap) writes mutations that will not sync. Previously the only
+    // signal was a stderr warn, invisible to --json consumers. Predicate and
+    // prose both come from the one health source (#1444). When this warning
+    // is present, the JSON envelope suppresses its process-level
+    // `gistInitWarning` duplicate — see `jsonSuccess` in formatters/json.ts.
+    const gistHealth = getStateManager().getGistHealth();
+    if (gistHealth.degraded) {
+        recordWarning(warnings, 'gist-init', 'Gist persistence degraded', null, renderGistWarning(gistHealth.degraded.cause));
     }
     // Surface Gist staleness up-front so consumers see it even if Phase 1 fails (#1193).
     const staleness = getStateManager().getStateStaleness();
@@ -574,46 +613,86 @@ async function executeDailyCheckInternal(token) {
     // Phase 3: Persist monthly analytics and store merged/closed PR history.
     // try-catch: analytics are supplementary — save failure should not crash the daily check.
     try {
+        // Previous run's digest — read BEFORE Phase 4 overwrites it. If a
+        // just-merged/closed PR was open during a prior enriched run, its
+        // openPRs entry carries firstMaintainerResponseAt for the ledger (#1461).
+        const previousDigest = getStateManager().getState().lastDigest;
         getStateManager().batch(() => {
-            updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+            const analyticsFailures = updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+            // Per-metric setter failures are caught inside updateMonthlyAnalytics
+            // (one bad metric must not sink the others); surface each in the run's
+            // warnings[] instead of dropping the returned labels (#1447).
+            for (const failure of analyticsFailures) {
+                recordWarning(warnings, 'analytics', failure, null, 'persist failed');
+            }
             // Store recently merged/closed PRs in the persistent arrays.
             // This ensures the mergedPRs/closedPRs ledger is populated even when
             // the dashboard is never opened (which has its own fetch path).
-            // addMergedPRs/addClosedPRs deduplicate by URL, so overlaps are safe.
+            // addMergedPRs/addClosedPRs deduplicate by URL (re-seen entries upgrade
+            // missing ledger fields in place), so overlaps are safe. openedAt comes
+            // free from the search result; firstMaintainerResponseAt is best-effort
+            // from the previous run's enriched digest — zero new API calls (#1461).
             if (recentlyMergedPRs.length > 0) {
-                getStateManager().addMergedPRs(recentlyMergedPRs.map((pr) => ({ url: pr.url, title: pr.title, mergedAt: pr.mergedAt })));
+                getStateManager().addMergedPRs(recentlyMergedPRs.map((pr) => ({
+                    url: pr.url,
+                    title: pr.title,
+                    mergedAt: pr.mergedAt,
+                    openedAt: pr.openedAt,
+                    firstMaintainerResponseAt: firstMaintainerResponseFromDigest(previousDigest, pr.url),
+                })));
             }
             if (recentlyClosedPRs.length > 0) {
-                getStateManager().addClosedPRs(recentlyClosedPRs.map((pr) => ({ url: pr.url, title: pr.title, closedAt: pr.closedAt })));
+                getStateManager().addClosedPRs(recentlyClosedPRs.map((pr) => ({
+                    url: pr.url,
+                    title: pr.title,
+                    closedAt: pr.closedAt,
+                    openedAt: pr.openedAt,
+                    firstMaintainerResponseAt: firstMaintainerResponseFromDigest(previousDigest, pr.url),
+                })));
             }
         });
     }
     catch (error) {
         recordWarning(warnings, 'analytics', 'persist monthly analytics', error);
     }
-    // Phase 3.5: Feed merged/closed PRs to oss-scout for cross-tool state sync.
-    if (recentlyMergedPRs.length > 0 || recentlyClosedPRs.length > 0) {
-        try {
-            const scout = await createAutopilotScout();
-            for (const pr of recentlyMergedPRs) {
-                scout.recordMergedPR({ url: pr.url, title: pr.title, mergedAt: pr.mergedAt, repo: pr.repo });
-            }
-            for (const pr of recentlyClosedPRs) {
-                scout.recordClosedPR({ url: pr.url, title: pr.title, closedAt: pr.closedAt, repo: pr.repo });
-            }
-            await scout.checkpoint();
-        }
-        catch (error) {
-            recordWarning(warnings, 'scout-sync', 'sync PR data to oss-scout', error);
-        }
+    // Phase 3.5: Close the merge loop (#1463). Join detected merges against
+    // the curated issue list (the PR URL recorded in an entry's sub-bullets
+    // is the only deterministic PR→issue link that exists — see
+    // merge-loop.ts) and auto-mark matching entries done. Safe to auto-run:
+    // the PR is MERGED per GitHub, and already-marked entries are quiet
+    // no-ops. Failures land in warnings[] via the shared collector.
+    const listUpdates = reconcileMergedPRsWithList({ mergedPRs: recentlyMergedPRs, warnings });
+    // Count freshly-merged PRs whose ledger entry has no learnings extraction
+    // stamp yet (#867 plumbing). Drives the action menu's extract_learnings
+    // nudge: it stays up for the whole recently-merged window (7 days) until
+    // the user runs the extraction, then self-clears.
+    let unextractedMergeCount = 0;
+    try {
+        const ledger = getStateManager().getState().mergedPRs ?? [];
+        const recentUrls = new Set(recentlyMergedPRs.map((pr) => pr.url));
+        unextractedMergeCount = ledger.filter((pr) => recentUrls.has(pr.url) && !pr.learningsExtractedAt).length;
     }
+    catch (error) {
+        recordWarning(warnings, 'merge-loop', 'count unextracted merged PRs', error);
+    }
+    // No scout pass here (#1458): the former Phase 3.5 fed recentlyMerged/ClosedPRs
+    // to an oss-scout instance and called scout.checkpoint(). Both halves were dead:
+    // scout's recordMergedPR/recordClosedPR deduplicate by URL against the ledger
+    // that Phase 3 just wrote (buildScoutState maps state.mergedPRs/closedPRs into
+    // the scout state), so they returned before touching any repo score; and under
+    // persistence:'provided' checkpoint() has no gist store and no local store, so
+    // it persisted nothing. Cross-tool sharing happens through buildScoutState
+    // reading AgentState, not through pushing events at scout.
     // 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;
     // Phase 4: Partition PRs, generate and save digest
     const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs, warnings);
     // Phase 5: Build structured output (capacity, dismiss filter, action menu)
-    const result = generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt);
+    const result = generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt, unextractedMergeCount);
+    if (listUpdates) {
+        result.listUpdates = listUpdates;
+    }
     // Checkpoint: push state to Gist if in Gist mode.
     // If getStateManagerAsync was not called before this command ran,
     // isGistMode() will be false and checkpoint is correctly skipped.

package/dist/commands/dashboard-cache.d.ts

@@ -0,0 +1,69 @@
+/**
+ * DashboardCache — the dashboard server's cached-response state.
+ *
+ * Extracted from dashboard-server.ts (#1457). Owns the cached digest,
+ * commented issues, partialFailures, built JSON payload, issue-list mtime
+ * and the last background-refresh error, plus buildDashboardJson (the
+ * payload builder the cache exists to memoize). The HTTP handlers consume
+ * it as a collaborator; nothing here touches req/res.
+ */
+import { type DashboardJsonData } from './dashboard-data.js';
+import { type DailyDigest, type AgentState, type CommentedIssue, type MergedPR, type ClosedPR } from '../core/types.js';
+/**
+ * Get the mtime of the vetted issue list file in ms, or null if unknown.
+ * Used to detect external edits and invalidate the cached dashboard payload.
+ */
+export declare function getIssueListMtimeMs(): number | null;
+/**
+ * Build the JSON payload that the SPA expects from GET /api/data.
+ *
+ * Exported for unit testing of response-shape concerns that the full
+ * handler harness can't reach (it bakes a stale cachedDigest at server
+ * start-up, so tests that need a specific digest should call this directly).
+ */
+export declare function buildDashboardJson(digest: DailyDigest, state: Readonly<AgentState>, commentedIssues: CommentedIssue[], allMergedPRs?: MergedPR[], allClosedPRs?: ClosedPR[], partialFailures?: string[]): DashboardJsonData;
+/** The slice of DashboardFetchResult the cache adopts after a full refresh. */
+export interface DashboardFetchSnapshot {
+    digest: DailyDigest;
+    commentedIssues: CommentedIssue[];
+    partialFailures: string[];
+}
+export declare class DashboardCache {
+    /** Decorates a partialFailures payload with the gist-sync lifecycle's
+     * warnings/banners (GistSyncCoordinator.withPendingGistWarnings) on
+     * every rebuild — injected so the two lifecycles stay uncoupled. */
+    private readonly mergeWarnings;
+    private cachedDigest;
+    private cachedCommentedIssues;
+    private cachedPartialFailures;
+    private cachedJsonData;
+    private cachedIssueListMtimeMs;
+    lastBackgroundRefreshError: string | null;
+    constructor(initialDigest: DailyDigest, 
+    /** Decorates a partialFailures payload with the gist-sync lifecycle's
+     * warnings/banners (GistSyncCoordinator.withPendingGistWarnings) on
+     * every rebuild — injected so the two lifecycles stay uncoupled. */
+    mergeWarnings: (failures: string[] | undefined) => string[] | undefined);
+    get digest(): DailyDigest;
+    get jsonData(): DashboardJsonData;
+    get issueListMtimeMs(): number | null;
+    /** Adopt a full fetchDashboardData result: replace the digest and
+     * commented issues unconditionally, and update the persistent banner
+     * signal — clear on a clean refresh, set when one or more sub-fetches
+     * degraded. See #1035. */
+    adoptFetchResult(result: DashboardFetchSnapshot): void;
+    /** A gist pull wholesale-replaces state, and the pulled state.lastDigest
+     * may be NEWER than this server's long-lived cachedDigest (another machine
+     * ran its daily check). Adopt it when its generatedAt is strictly newer so
+     * cross-machine results appear without a manual full refresh (#1446
+     * item 6). Unparsable timestamps compare as NaN and never adopt —
+     * conservative: keep what we have. */
+    adoptNewerPulledDigest(pulled: DailyDigest | undefined): void;
+    /** Rebuild the cached JSON payload from the cached digest + the given
+     * state, then stamp the issue-list mtime the payload reflects. Throws
+     * when buildDashboardJson does — on failure neither the payload nor the
+     * mtime is updated, so the next request retries the rebuild. `issueListMtimeMs`
+     * lets GET /api/data stamp the value it compared against (#924); the other
+     * call sites re-stat after the build. */
+    rebuild(state: Readonly<AgentState>, allMergedPRs?: MergedPR[], allClosedPRs?: ClosedPR[], issueListMtimeMs?: number | null): void;
+}

package/dist/commands/dashboard-cache.js

@@ -0,0 +1,219 @@
+/**
+ * DashboardCache — the dashboard server's cached-response state.
+ *
+ * Extracted from dashboard-server.ts (#1457). Owns the cached digest,
+ * commented issues, partialFailures, built JSON payload, issue-list mtime
+ * and the last background-refresh error, plus buildDashboardJson (the
+ * payload builder the cache exists to memoize). The HTTP handlers consume
+ * it as a collaborator; nothing here touches req/res.
+ */
+import * as fs from 'node:fs';
+import { getStateManager, applyStatusOverrides, classifyAttentionBucket } from '../core/index.js';
+import { errorMessage } from '../core/errors.js';
+import { warn } from '../core/logger.js';
+import { computePRsByRepo, computeTopRepos, getMonthlyData, buildDashboardStats, reconcileShelvePartition, storedToMergedPRs, storedToClosedPRs, } from './dashboard-data.js';
+import { detectIssueList } from './startup.js';
+import { parseIssueList } from './parse-list.js';
+import { isBelowMinStars, } from '../core/types.js';
+const MODULE = 'dashboard-server';
+/**
+ * Read and parse the vetted issue list file (non-fatal on failure).
+ *
+ * @param failures - Optional collector (#1448): a read/parse failure pushes a
+ *   label so the SPA's partialFailures banner shows the panel is degraded
+ *   rather than silently empty. "No list detected" is not a failure and
+ *   pushes nothing.
+ */
+function readVettedIssues(failures) {
+    try {
+        const info = detectIssueList();
+        if (!info)
+            return null;
+        const content = fs.readFileSync(info.path, 'utf8');
+        return parseIssueList(content);
+    }
+    catch (error) {
+        warn(MODULE, `Failed to read vetted issue list: ${errorMessage(error)}`);
+        failures?.push('read vetted issue list');
+        return null;
+    }
+}
+/**
+ * Get the mtime of the vetted issue list file in ms, or null if unknown.
+ * Used to detect external edits and invalidate the cached dashboard payload.
+ */
+export function getIssueListMtimeMs() {
+    try {
+        const info = detectIssueList();
+        if (!info)
+            return null;
+        return fs.statSync(info.path).mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Build the JSON payload that the SPA expects from GET /api/data.
+ *
+ * Exported for unit testing of response-shape concerns that the full
+ * handler harness can't reach (it bakes a stale cachedDigest at server
+ * start-up, so tests that need a specific digest should call this directly).
+ */
+export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs, partialFailures) {
+    // Collect build-local failures (#1448) alongside the caller-provided ones
+    // so degradations detected during THIS build (vetted-list read failure,
+    // status-override application failure) reach the SPA's partialFailures
+    // banner instead of living only in stderr.
+    const buildFailures = [...(partialFailures ?? [])];
+    // Apply status overrides ONCE, before the shelve partition is derived, so
+    // the dashboard partitions on the same post-override status the CLI
+    // partitions on (#1416). This also covers overrides set AFTER the digest
+    // was cached (a dashboard move stores an override; the action path rebuilds
+    // from the cached digest). Work on a copy — the caller's cached digest must
+    // not accumulate per-request derivations.
+    const overriddenDigest = {
+        ...digest,
+        openPRs: applyStatusOverrides(digest.openPRs || [], state, buildFailures),
+        summary: { ...digest.summary },
+    };
+    // Re-derive the shelve partition from the CURRENT state before reading it.
+    // The POST /api/action path rebuilds with a cached digest whose shelvedPRs
+    // predates the shelve/unshelve, so without this the SPA action appears to do
+    // nothing until the next full /api/refresh.
+    reconcileShelvePartition(overriddenDigest, state);
+    const prsByRepo = computePRsByRepo(overriddenDigest, state);
+    const topRepos = computeTopRepos(prsByRepo);
+    const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
+    // Derive from state if not provided (e.g. initial load from cached state)
+    const mergedPRs = allMergedPRs ?? storedToMergedPRs(getStateManager().getMergedPRs());
+    const closedPRs = allClosedPRs ?? storedToClosedPRs(getStateManager().getClosedPRs());
+    // Filter out PRs from repos below the minStars threshold
+    const minStars = state.config.minStars ?? 50;
+    const repoScores = state.repoScores || {};
+    const isAboveMinStars = (pr) => !isBelowMinStars(repoScores[pr.repo]?.stargazersCount, minStars);
+    const filteredMergedPRs = mergedPRs.filter(isAboveMinStars);
+    const filteredClosedPRs = closedPRs.filter(isAboveMinStars);
+    const stats = buildDashboardStats(overriddenDigest, 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 };
+        }
+    }
+    // A vetted-list read failure reaches the SPA banner via buildFailures
+    // instead of leaving the panel silently empty (#1448).
+    const vettedIssues = readVettedIssues(buildFailures);
+    if (vettedIssues) {
+        stats.availableIssues = vettedIssues.availableCount;
+    }
+    return {
+        stats,
+        prsByRepo,
+        topRepos: topRepos.map(([repo, data]) => ({ repo, ...data })),
+        monthlyMerged,
+        monthlyOpened,
+        monthlyClosed,
+        // #1352: stamp the unified attention bucket so the SPA renders the same
+        // taxonomy the CLI brief counts (single classifier, no second opinion).
+        // Overrides were already applied when overriddenDigest was built — a
+        // second application here would be a no-op but obscures the single
+        // apply-then-partition ordering (#1416).
+        activePRs: (overriddenDigest.openPRs || []).map((pr) => ({
+            ...pr,
+            attentionBucket: classifyAttentionBucket(pr),
+        })),
+        // Source of truth is digest.shelvedPRs (union of explicitly-shelved URLs
+        // and dormant-non-addressing PRs auto-shelved for display). Returning
+        // only state.config.shelvedPRUrls would under-count and desync from
+        // stats.shelvedPRs, which is already derived from digest.shelvedPRs. (#981)
+        shelvedPRUrls: (overriddenDigest.shelvedPRs || []).map((ref) => ref.url),
+        recentlyMergedPRs: overriddenDigest.recentlyMergedPRs || [],
+        recentlyClosedPRs: overriddenDigest.recentlyClosedPRs || [],
+        autoUnshelvedPRs: overriddenDigest.autoUnshelvedPRs || [],
+        commentedIssues,
+        issueResponses,
+        allMergedPRs: filteredMergedPRs,
+        allClosedPRs: filteredClosedPRs,
+        repoMetadata,
+        vettedIssues,
+        // Dedup: the fetch path already applies status overrides into the cached
+        // partialFailures, and the rebuild applies them again above — the same
+        // failing override must not appear (and be counted) twice (#1448).
+        partialFailures: buildFailures.length > 0 ? [...new Set(buildFailures)] : undefined,
+    };
+}
+export class DashboardCache {
+    mergeWarnings;
+    // Start immediately with state.json data (written by the daily check that
+    // precedes this server launch). A background GitHub fetch refreshes the
+    // cache after the port is bound, so the startup poller sees us in time.
+    cachedDigest;
+    cachedCommentedIssues = [];
+    // Persist the last-known partialFailures across rebuild requests (#1035).
+    // Cleared only when a fresh fetchDashboardData returns zero failures;
+    // re-threaded into every buildDashboardJson call so the SPA banner does
+    // not disappear when /api/data rebuilds after a state change or after a
+    // POST /api/action completes.
+    cachedPartialFailures = undefined;
+    cachedJsonData;
+    cachedIssueListMtimeMs;
+    // Tracks the last background-refresh failure so /api/data can surface
+    // staleness to the SPA via the X-Dashboard-Stale header (#1205). Cleared
+    // when a refresh succeeds. Without this, token expiry / GitHub outage
+    // produces silent stale data hours old with no client-visible signal.
+    lastBackgroundRefreshError = null;
+    constructor(initialDigest, 
+    /** Decorates a partialFailures payload with the gist-sync lifecycle's
+     * warnings/banners (GistSyncCoordinator.withPendingGistWarnings) on
+     * every rebuild — injected so the two lifecycles stay uncoupled. */
+    mergeWarnings) {
+        this.mergeWarnings = mergeWarnings;
+        this.cachedDigest = initialDigest;
+        this.cachedIssueListMtimeMs = getIssueListMtimeMs();
+    }
+    get digest() {
+        return this.cachedDigest;
+    }
+    get jsonData() {
+        return this.cachedJsonData;
+    }
+    get issueListMtimeMs() {
+        return this.cachedIssueListMtimeMs;
+    }
+    /** Adopt a full fetchDashboardData result: replace the digest and
+     * commented issues unconditionally, and update the persistent banner
+     * signal — clear on a clean refresh, set when one or more sub-fetches
+     * degraded. See #1035. */
+    adoptFetchResult(result) {
+        this.cachedDigest = result.digest;
+        this.cachedCommentedIssues = result.commentedIssues;
+        this.cachedPartialFailures = result.partialFailures.length > 0 ? result.partialFailures : undefined;
+    }
+    /** A gist pull wholesale-replaces state, and the pulled state.lastDigest
+     * may be NEWER than this server's long-lived cachedDigest (another machine
+     * ran its daily check). Adopt it when its generatedAt is strictly newer so
+     * cross-machine results appear without a manual full refresh (#1446
+     * item 6). Unparsable timestamps compare as NaN and never adopt —
+     * conservative: keep what we have. */
+    adoptNewerPulledDigest(pulled) {
+        if (!pulled)
+            return;
+        if (Date.parse(pulled.generatedAt) > Date.parse(this.cachedDigest.generatedAt)) {
+            this.cachedDigest = pulled;
+        }
+    }
+    /** Rebuild the cached JSON payload from the cached digest + the given
+     * state, then stamp the issue-list mtime the payload reflects. Throws
+     * when buildDashboardJson does — on failure neither the payload nor the
+     * mtime is updated, so the next request retries the rebuild. `issueListMtimeMs`
+     * lets GET /api/data stamp the value it compared against (#924); the other
+     * call sites re-stat after the build. */
+    rebuild(state, allMergedPRs, allClosedPRs, issueListMtimeMs) {
+        this.cachedJsonData = buildDashboardJson(this.cachedDigest, state, this.cachedCommentedIssues, allMergedPRs, allClosedPRs, this.mergeWarnings(this.cachedPartialFailures));
+        this.cachedIssueListMtimeMs = issueListMtimeMs !== undefined ? issueListMtimeMs : getIssueListMtimeMs();
+    }
+}