@oss-autopilot/core 1.16.1 → 1.17.0

package/dist/cli.js

@@ -37,16 +37,28 @@ program.hook('preAction', async (thisCommand, actionCommand) => {
     if (!localOnlySet.has(commandName)) {
         const token = await getGitHubTokenAsync();
         if (!token) {
-            console.error('Error: GitHub authentication required.');
-            console.error('');
-            console.error('Option 1 (Recommended): Install and authenticate GitHub CLI');
-            console.error('  Install: https://cli.github.com/');
-            console.error('  Then run: gh auth login');
-            console.error('');
-            console.error('Option 2: Set GITHUB_TOKEN environment variable');
-            console.error('  export GITHUB_TOKEN="your-github-token-here"');
-            console.error('');
-            console.error('Then run your command again.');
+            // Honor --json at the CLI boundary so machine consumers (plugins, MCP
+            // stdio harnesses, scripts) get a parseable envelope instead of a
+            // stderr blob followed by a non-zero exit. Commander has already parsed
+            // the action's own options, so we check both the action command and the
+            // raw argv as a fallback (#1056 M20).
+            const wantsJson = Boolean(actionCommand.opts().json) || process.argv.includes('--json');
+            if (wantsJson) {
+                const { outputJsonError } = await import('./formatters/json.js');
+                outputJsonError('GitHub authentication required. Install gh CLI and run `gh auth login`, or set GITHUB_TOKEN.', 'AUTH_REQUIRED');
+            }
+            else {
+                console.error('Error: GitHub authentication required.');
+                console.error('');
+                console.error('Option 1 (Recommended): Install and authenticate GitHub CLI');
+                console.error('  Install: https://cli.github.com/');
+                console.error('  Then run: gh auth login');
+                console.error('');
+                console.error('Option 2: Set GITHUB_TOKEN environment variable');
+                console.error('  export GITHUB_TOKEN="your-github-token-here"');
+                console.error('');
+                console.error('Then run your command again.');
+            }
             process.exit(1);
         }
         // Activate Gist persistence if configured, before any command runs.

package/dist/commands/comments.js

@@ -2,7 +2,10 @@
  * Comments, Post, and Claim commands
  * Handles GitHub comment interactions
  */
-import { getStateManager, getOctokit, parseGitHubUrl, requireGitHubToken } from '../core/index.js';
+import { getStateManager, getOctokit, parseGitHubUrl, requireGitHubToken, maybeCheckpoint } from '../core/index.js';
+import { ValidationError } from '../core/errors.js';
+import { warn } from '../core/logger.js';
+const MODULE = 'comments';
 import { paginateAll } from '../core/pagination.js';
 import { validateUrl, validateMessage, validateGitHubUrl, PR_URL_PATTERN, ISSUE_OR_PR_URL_PATTERN, ISSUE_URL_PATTERN, } from './validation.js';
 /**
@@ -24,7 +27,7 @@ export async function runComments(options) {
     // Parse PR URL
     const parsed = parseGitHubUrl(options.prUrl);
     if (!parsed || parsed.type !== 'pull') {
-        throw new Error('Invalid PR URL format');
+        throw new ValidationError('Invalid PR URL format');
     }
     const { owner, repo, number: pull_number } = parsed;
     // Get PR details
@@ -119,14 +122,14 @@ export async function runPost(options) {
     validateUrl(options.url);
     validateGitHubUrl(options.url, ISSUE_OR_PR_URL_PATTERN, 'issue or PR');
     if (!options.message.trim()) {
-        throw new Error('No message provided');
+        throw new ValidationError('No message provided');
     }
     validateMessage(options.message);
     const token = requireGitHubToken();
     // Parse URL
     const parsed = parseGitHubUrl(options.url);
     if (!parsed) {
-        throw new Error('Invalid GitHub URL format');
+        throw new ValidationError('Invalid GitHub URL format');
     }
     const { owner, repo, number } = parsed;
     const octokit = getOctokit(token);
@@ -160,7 +163,7 @@ export async function runClaim(options) {
     // Parse URL
     const parsed = parseGitHubUrl(options.issueUrl);
     if (!parsed || parsed.type !== 'issues') {
-        throw new Error('Invalid issue URL format (must be an issue, not a PR)');
+        throw new ValidationError('Invalid issue URL format (must be an issue, not a PR)');
     }
     const { owner, repo, number } = parsed;
     const octokit = getOctokit(token);
@@ -170,6 +173,26 @@ export async function runClaim(options) {
         issue_number: number,
         body: message,
     });
+    // Fetch the real issue title + labels so the tracked entry has useful metadata
+    // rather than a permanent "(claimed)" placeholder that never gets backfilled
+    // (#1056 M24). Best-effort: if the fetch fails, fall back to the placeholder
+    // so state still records the claim.
+    let issueTitle = '(claimed)';
+    let issueLabels = [];
+    let issueCreatedAt = new Date().toISOString();
+    try {
+        const { data: issue } = await octokit.issues.get({ owner, repo, issue_number: number });
+        if (issue.title)
+            issueTitle = issue.title;
+        issueLabels = (issue.labels ?? [])
+            .map((l) => (typeof l === 'string' ? l : (l.name ?? '')))
+            .filter((name) => Boolean(name));
+        if (issue.created_at)
+            issueCreatedAt = issue.created_at;
+    }
+    catch (error) {
+        warn(MODULE, `Claimed ${options.issueUrl} but failed to enrich issue metadata (title/labels): ${error instanceof Error ? error.message : error}`);
+    }
     // Add to tracked issues — non-fatal if state save fails (comment already posted)
     try {
         const stateManager = getStateManager();
@@ -178,27 +201,22 @@ export async function runClaim(options) {
             url: options.issueUrl,
             repo: `${owner}/${repo}`,
             number,
-            title: '(claimed)',
+            title: issueTitle,
             status: 'claimed',
-            labels: [],
-            createdAt: new Date().toISOString(),
+            labels: issueLabels,
+            createdAt: issueCreatedAt,
             updatedAt: new Date().toISOString(),
             vetted: false,
         });
-        // 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.
-        try {
-            if (stateManager.isGistMode()) {
-                await stateManager.checkpoint();
-            }
-        }
-        catch {
-            /* best-effort */
-        }
+        // Push state to Gist if in Gist mode. Best-effort — logs on failure
+        // rather than silently swallowing, so operators see the degraded-sync
+        // signal (#1036 audit H1).
+        await maybeCheckpoint(stateManager, MODULE);
     }
     catch (error) {
-        console.error(`Warning: Comment posted on ${options.issueUrl} but failed to save to local state: ${error instanceof Error ? error.message : error}`);
+        // Structured warning instead of bare console.error so the breadcrumb shows
+        // up in the plugin's log pipeline (#1056 M24).
+        warn(MODULE, `Comment posted on ${options.issueUrl} but failed to save to local state: ${error instanceof Error ? error.message : error}`);
     }
     return {
         commentUrl: comment.html_url,

package/dist/commands/config.d.ts

@@ -2,26 +2,33 @@
  * Config command
  * Shows or updates configuration
  */
+import { type ConfigKeyDef } from '../core/index.js';
 import type { ConfigOutput } from '../formatters/json.js';
 interface ConfigOptions {
     key?: string;
     value?: string;
+    listKeys?: boolean;
 }
 export interface ConfigSetOutput {
     success: true;
     key: string;
     value: string;
 }
-export type ConfigCommandOutput = ConfigOutput | ConfigSetOutput;
+export interface ConfigListKeysOutput {
+    keys: readonly ConfigKeyDef[];
+}
+export type ConfigCommandOutput = ConfigOutput | ConfigSetOutput | ConfigListKeysOutput;
 /**
  * Read or write user configuration settings.
  * When called without a key, returns the full config.
  * When called with a key and value, updates the setting.
+ * When called with --list-keys, returns the full registry of known keys.
  *
  * @param options - Config options
  * @param options.key - Setting key (e.g., 'username', 'add-language', 'exclude-repo')
  * @param options.value - Setting value (required when key is provided)
- * @returns Current config (when reading) or success confirmation (when writing)
+ * @param options.listKeys - When true, return the registry of known keys
+ * @returns Current config, success confirmation, or key registry
  * @throws {Error} If the key is unknown or the value is invalid
  */
 export declare function runConfig(options: ConfigOptions): Promise<ConfigCommandOutput>;

package/dist/commands/config.js

@@ -2,7 +2,8 @@
  * Config command
  * Shows or updates configuration
  */
-import { getStateManager } from '../core/index.js';
+import { CONFIG_KEY_REGISTRY, formatUnknownKeyError, getStateManager } from '../core/index.js';
+import { ValidationError } from '../core/errors.js';
 import { ISSUE_SCOPES, DIFF_TOOLS } from '../core/types.js';
 import { validateGitHubUsername } from './validation.js';
 function validateScope(value) {
@@ -15,14 +16,22 @@ function validateScope(value) {
  * Read or write user configuration settings.
  * When called without a key, returns the full config.
  * When called with a key and value, updates the setting.
+ * When called with --list-keys, returns the full registry of known keys.
  *
  * @param options - Config options
  * @param options.key - Setting key (e.g., 'username', 'add-language', 'exclude-repo')
  * @param options.value - Setting value (required when key is provided)
- * @returns Current config (when reading) or success confirmation (when writing)
+ * @param options.listKeys - When true, return the registry of known keys
+ * @returns Current config, success confirmation, or key registry
  * @throws {Error} If the key is unknown or the value is invalid
  */
 export async function runConfig(options) {
+    if (options.listKeys) {
+        if (options.key || options.value) {
+            throw new ValidationError('`--list-keys` cannot be combined with a key/value. Run `config --list-keys` on its own.');
+        }
+        return { keys: CONFIG_KEY_REGISTRY };
+    }
     const stateManager = getStateManager();
     const currentConfig = stateManager.getState().config;
     if (!options.key) {
@@ -118,7 +127,7 @@ export async function runConfig(options) {
             });
             break;
         default:
-            throw new Error(`Unknown config key: ${options.key}`);
+            throw new ValidationError(formatUnknownKeyError(options.key, 'config'));
     }
     return { success: true, key: options.key, value };
 }

package/dist/commands/daily.d.ts

@@ -7,7 +7,7 @@
  * orchestration layer that wires up the phases and handles I/O.
  */
 import { type DailyDigest, type CommentedIssue, type PRCheckFailure, type RepoGroup, type AgentState, type StarFilter } from '../core/index.js';
-import { type DailyOutput, type CapacityAssessment, type ActionableIssue, type ActionMenu } from '../formatters/json.js';
+import { type DailyOutput, type DailyWarning, type CapacityAssessment, type ActionableIssue, type ActionMenu } from '../formatters/json.js';
 export { applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
 /**
  * Build a star filter from state for use in fetchUserPRCounts.
@@ -32,6 +32,8 @@ export interface DailyCheckResult {
     commentedIssues: CommentedIssue[];
     repoGroups: RepoGroup[];
     failures: PRCheckFailure[];
+    /** Non-fatal warnings from ancillary pipeline phases — see #1042. */
+    warnings: DailyWarning[];
 }
 /**
  * Convert a full DailyCheckResult to the compact DailyOutput for JSON serialization (#287).

package/dist/commands/daily.js

@@ -7,13 +7,35 @@
  * 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, } from '../core/index.js';
-import { errorMessage, isRateLimitOrAuthError, nonFatalCatch } from '../core/errors.js';
+import { errorMessage, isRateLimitOrAuthError } from '../core/errors.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, } from '../formatters/json.js';
 const MODULE = 'daily';
+/**
+ * Record a non-fatal failure: push a structured entry into the run's warnings
+ * collector AND emit the existing log line. Consumers (dashboard, MCP, tests)
+ * inspect `DailyOutput.warnings` so a partial run is visible beyond log noise.
+ * See #1042.
+ */
+function recordWarning(warnings, phase, operation, err, humanMessage) {
+    const message = humanMessage ?? errorMessage(err);
+    warnings.push({ phase, operation, message });
+    warn(MODULE, `${operation}: ${message}`);
+}
+/**
+ * Variant of `nonFatalCatch` that also records a structured warning. Returns
+ * the fallback value on error (same semantics as `nonFatalCatch`) AND pushes
+ * an entry into the collector so the failure shows up in `DailyOutput.warnings`.
+ */
+function nonFatalCatchWithWarning(opts) {
+    return (err) => {
+        recordWarning(opts.warnings, opts.phase, opts.operation, err);
+        return opts.fallback;
+    };
+}
 // Re-export domain functions so existing consumers (tests, dashboard, startup)
 // can continue importing from './daily.js' without changes.
 export { applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, printDigest, CRITICAL_STATUSES, } from '../core/index.js';
@@ -45,13 +67,33 @@ export function buildStarFilter(state) {
  * Retrieves open PRs, merged/closed counts, recently closed/merged PRs, and
  * issue conversation data — all in parallel where possible.
  */
-async function fetchPRData(prMonitor, token) {
+async function fetchPRData(prMonitor, token, warnings) {
     // Fetch all open PRs fresh from GitHub
-    const { prs, failures } = await prMonitor.fetchUserOpenPRs();
+    const fetchResult = await prMonitor.fetchUserOpenPRs();
+    const { prs, failures } = fetchResult;
     // Log any failures (but continue with successful checks)
     if (failures.length > 0) {
+        // Per-PR detail lives in `result.failures`; record a rollup warning so
+        // consumers that only read `warnings[]` still see the degradation signal.
+        warnings.push({
+            phase: 'fetch',
+            operation: 'fetch open PRs',
+            message: `${failures.length} PR fetch(es) failed`,
+        });
         warn(MODULE, `${failures.length} PR fetch(es) failed`);
     }
+    // Surface search-API truncation warnings (#1057 M25) so daily consumers
+    // see the partial-view signal in their `warnings` array rather than only
+    // in server logs.
+    if (fetchResult.warnings) {
+        for (const message of fetchResult.warnings) {
+            warnings.push({
+                phase: 'fetch',
+                operation: 'fetch open PRs (truncated)',
+                message,
+            });
+        }
+    }
     // Build star filter from cached repoScores so low-star repos are excluded
     // from merged/closed histograms (#576). Repos with no cached star data pass through.
     const state = getStateManager().getState();
@@ -60,31 +102,40 @@ async function fetchPRData(prMonitor, token) {
     // All stats fetches are non-critical (cosmetic/scoring), so isolate their failure
     const issueMonitor = new IssueConversationMonitor(token);
     const [mergedResult, closedResult, recentlyClosedPRs, recentlyMergedPRs, issueConversationResult] = await Promise.all([
-        prMonitor.fetchUserMergedPRCounts(starFilter).catch(nonFatalCatch({
-            module: MODULE,
-            label: 'fetch merged PR counts',
+        prMonitor.fetchUserMergedPRCounts(starFilter).catch(nonFatalCatchWithWarning({
+            warnings,
+            phase: 'fetch',
+            operation: 'fetch merged PR counts',
+            fallback: emptyPRCountsResult(),
+        })),
+        prMonitor.fetchUserClosedPRCounts(starFilter).catch(nonFatalCatchWithWarning({
+            warnings,
+            phase: 'fetch',
+            operation: 'fetch closed PR counts',
             fallback: emptyPRCountsResult(),
         })),
-        prMonitor
-            .fetchUserClosedPRCounts(starFilter)
-            .catch(nonFatalCatch({ module: MODULE, label: 'fetch closed PR counts', fallback: emptyPRCountsResult() })),
-        prMonitor
-            .fetchRecentlyClosedPRs()
-            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently closed PRs', fallback: [] })),
-        prMonitor
-            .fetchRecentlyMergedPRs()
-            .catch(nonFatalCatch({ module: MODULE, label: 'fetch recently merged PRs', fallback: [] })),
+        prMonitor.fetchRecentlyClosedPRs().catch(nonFatalCatchWithWarning({
+            warnings,
+            phase: 'fetch',
+            operation: 'fetch recently closed PRs',
+            fallback: [],
+        })),
+        prMonitor.fetchRecentlyMergedPRs().catch(nonFatalCatchWithWarning({
+            warnings,
+            phase: 'fetch',
+            operation: 'fetch recently merged PRs',
+            fallback: [],
+        })),
         // Issue conversation fetch has custom messaging based on the error content, so it keeps its bespoke catch.
         issueMonitor.fetchCommentedIssues().catch((error) => {
             if (isRateLimitOrAuthError(error))
                 throw error;
             const msg = errorMessage(error);
-            if (msg.includes('No GitHub username configured')) {
-                warn(MODULE, `Issue conversation tracking requires setup: ${msg}`);
-            }
-            else {
-                warn(MODULE, `Issue conversation fetch failed: ${msg}`);
-            }
+            const needsSetup = msg.includes('No GitHub username configured');
+            const humanMessage = needsSetup
+                ? `Issue conversation tracking requires setup: ${msg}`
+                : `Issue conversation fetch failed: ${msg}`;
+            recordWarning(warnings, 'fetch', 'fetch commented issues', error, humanMessage);
             return {
                 issues: [],
                 failures: [{ issueUrl: 'N/A', error: `Issue conversation fetch failed: ${msg}` }],
@@ -93,6 +144,11 @@ async function fetchPRData(prMonitor, token) {
     ]);
     const commentedIssues = issueConversationResult.issues;
     if (issueConversationResult.failures.length > 0) {
+        warnings.push({
+            phase: 'fetch',
+            operation: 'fetch commented issues',
+            message: `${issueConversationResult.failures.length} issue conversation check(s) failed`,
+        });
         warn(MODULE, `${issueConversationResult.failures.length} issue conversation check(s) failed`);
     }
     const { repos: mergedCounts, monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
@@ -116,7 +172,7 @@ async function fetchPRData(prMonitor, token) {
  * Applies stale repo reset, updates merged/closed counts, computes and stores
  * repo signals from open PR data, refreshes star counts, and syncs trusted projects.
  */
-async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
+async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warnings) {
     const stateManager = getStateManager();
     // Batch all synchronous score mutations for a single disk write.
     // Per-repo try-catch: a single corrupted repo should not prevent updates to others.
@@ -149,6 +205,14 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
                 }
             }
             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.
+                warnings.push({
+                    phase: 'repo-scores',
+                    operation: 'update merged counts',
+                    message: `All ${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.`);
             }
             // Populate closedWithoutMergeCount in repo scores.
@@ -167,6 +231,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
                 }
             }
             if (closedCountFailures === closedCounts.size && closedCounts.size > 0) {
+                warnings.push({
+                    phase: 'repo-scores',
+                    operation: 'update closed counts',
+                    message: `All ${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.`);
             }
             // Update repo signals from observed open PR data
@@ -182,12 +251,17 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
                 }
             }
             if (signalUpdateFailures === repoSignals.size && repoSignals.size > 0) {
+                warnings.push({
+                    phase: 'repo-scores',
+                    operation: 'update repo signals',
+                    message: `All ${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.`);
             }
         });
     }
     catch (error) {
-        warn(MODULE, `Failed to persist repo score updates: ${errorMessage(error)}`);
+        recordWarning(warnings, 'repo-scores', 'persist repo score updates', error);
     }
     // Fetch metadata (stars + language) for all scored repos — async, so outside the batch above
     const allRepos = Object.keys(stateManager.getState().repoScores);
@@ -198,7 +272,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
     catch (error) {
         if (isRateLimitOrAuthError(error))
             throw error;
-        warn(MODULE, `Failed to fetch repo metadata: ${errorMessage(error)}`);
+        recordWarning(warnings, 'repo-scores', 'fetch repo metadata', 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();
     }
@@ -216,6 +290,11 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
                 }
             }
             if (metadataUpdateFailures === repoMetadata.size && repoMetadata.size > 0) {
+                warnings.push({
+                    phase: 'repo-scores',
+                    operation: 'update repo metadata',
+                    message: `All ${repoMetadata.size} metadata update(s) failed. This may indicate corrupted state.`,
+                });
                 warn(MODULE, `[ALL_METADATA_UPDATES_FAILED] All ${repoMetadata.size} metadata update(s) failed.`);
             }
             // Auto-sync trustedProjects from repos with merged PRs
@@ -230,12 +309,17 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
                 }
             }
             if (trustSyncFailures === mergedCounts.size && mergedCounts.size > 0) {
+                warnings.push({
+                    phase: 'repo-scores',
+                    operation: 'sync trusted projects',
+                    message: `All ${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.`);
             }
         });
     }
     catch (error) {
-        warn(MODULE, `Failed to persist metadata/trust updates: ${errorMessage(error)}`);
+        recordWarning(warnings, 'repo-scores', 'persist metadata/trust updates', error);
     }
 }
 /**
@@ -243,7 +327,7 @@ async function updateRepoScores(prMonitor, prs, mergedCounts, closedCounts) {
  * Auto-unshelves PRs where maintainers have engaged, generates the digest,
  * and persists state.
  */
-function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
+function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs, warnings) {
     const stateManager = getStateManager();
     // Apply dashboard/CLI status overrides before partitioning.
     // This ensures PRs reclassified in the dashboard (e.g., "Need Attention" → "Waiting")
@@ -290,7 +374,7 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
         });
     }
     catch (error) {
-        warn(MODULE, `Failed to persist partition state: ${errorMessage(error)}`);
+        recordWarning(warnings, 'partition', 'persist partition state', error);
     }
     // Digest was created inside batch — reconstruct from state
     const digest = stateManager.getState().lastDigest;
@@ -301,7 +385,7 @@ function partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs) {
  * Assesses capacity, filters dismissed issues, computes actionable items,
  * and assembles the action menu.
  */
-function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, previousLastDigestAt) {
+function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt) {
     const stateManager = getStateManager();
     // Assess capacity from active PRs only (shelved PRs excluded)
     const capacity = assessCapacity(activePRs, stateManager.getState().config.maxActivePRs, shelvedPRs.length);
@@ -330,7 +414,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
                             stateManager.undismissIssue(issue.url);
                         }
                         catch (error) {
-                            warn(MODULE, `Failed to persist auto-undismiss for ${issue.url}: ${errorMessage(error)}`);
+                            recordWarning(warnings, 'dismiss-filter', `persist auto-undismiss for ${issue.url}`, error);
                         }
                         return true;
                     }
@@ -341,7 +425,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
         });
     }
     catch (error) {
-        warn(MODULE, `Failed to persist auto-undismiss state: ${errorMessage(error)}`);
+        recordWarning(warnings, 'dismiss-filter', 'persist auto-undismiss state', error);
     }
     const issueResponses = filteredCommentedIssues.filter((i) => i.status === 'new_response');
     const summary = formatSummary(digest, capacity, issueResponses);
@@ -361,6 +445,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
         commentedIssues: filteredCommentedIssues,
         repoGroups,
         failures,
+        warnings,
     };
 }
 // ---------------------------------------------------------------------------
@@ -385,6 +470,7 @@ export function toDailyOutput(result) {
         commentedIssues: result.commentedIssues,
         repoGroups: compactRepoGroups(result.repoGroups),
         failures: result.failures,
+        warnings: result.warnings,
     };
 }
 /**
@@ -415,10 +501,13 @@ export async function executeDailyCheck(token) {
  */
 async function executeDailyCheckInternal(token) {
     const prMonitor = new PRMonitor(token);
+    // One collector shared by every phase — threaded through explicitly so the
+    // callgraph documents which phases can produce non-fatal warnings. See #1042.
+    const warnings = [];
     // Phase 1: Fetch all PR data from GitHub
-    const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token);
+    const { prs, failures, mergedCounts, closedCounts, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed, recentlyClosedPRs, recentlyMergedPRs, commentedIssues, } = await fetchPRData(prMonitor, token, warnings);
     // Phase 2: Update repo scores (signals, star counts, trust sync)
-    await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts);
+    await updateRepoScores(prMonitor, prs, mergedCounts, closedCounts, warnings);
     // 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 {
@@ -437,7 +526,7 @@ async function executeDailyCheckInternal(token) {
         });
     }
     catch (error) {
-        warn(MODULE, `Failed to persist monthly analytics: ${errorMessage(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) {
@@ -452,16 +541,16 @@ async function executeDailyCheckInternal(token) {
             await scout.checkpoint();
         }
         catch (error) {
-            warn(MODULE, `Failed to sync PR data to oss-scout: ${errorMessage(error)}`);
+            recordWarning(warnings, 'scout-sync', 'sync PR data to oss-scout', 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;
     // Phase 4: Partition PRs, generate and save digest
-    const { activePRs, shelvedPRs, digest } = partitionPRs(prMonitor, prs, recentlyClosedPRs, recentlyMergedPRs);
+    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, previousLastDigestAt);
+    const result = generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, failures, warnings, previousLastDigestAt);
     // 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.
@@ -472,7 +561,7 @@ async function executeDailyCheckInternal(token) {
         }
     }
     catch (err) {
-        warn(MODULE, `Gist checkpoint failed: ${errorMessage(err)}`);
+        recordWarning(warnings, 'gist-checkpoint', 'Gist checkpoint', err);
     }
     return result;
 }

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

@@ -48,6 +48,14 @@ export interface DashboardJsonData {
     vettedIssues?: ParseIssueListOutput | null;
     offline?: boolean;
     lastUpdated?: string;
+    /**
+     * Labels of sub-fetches that degraded to empty fallbacks during this data
+     * build. Non-empty means one or more background calls failed and the
+     * corresponding sections of the response are approximations (stale or
+     * zero'd) rather than authoritative. The SPA surfaces this as a banner
+     * so users know the dashboard is showing partial data. See #1035.
+     */
+    partialFailures?: string[];
 }
 /** Action types the dashboard can request via POST /api/action. */
 export type DashboardActionType = 'move' | 'dismiss_issue_response';
@@ -62,8 +70,15 @@ export declare function buildDashboardStats(digest: DailyDigest, state: Readonly
 /**
  * Merge fresh API counts into existing stored counts.
  * Months present in the fresh data are updated; months only in the existing data are preserved.
- * This prevents historical data loss when the API returns incomplete results
- * (e.g. due to pagination limits or transient failures).
+ *
+ * Anti-regression guard (#1035): when the fresh count for a given month is
+ * smaller than the already-stored count for that month, we keep the larger
+ * value. This matters when the fresh fetch was capped (pagination limits,
+ * 1000-result Search API ceiling, or partial failures) and would otherwise
+ * silently overwrite authoritative historical data with a partial window.
+ * The trade-off: a month that genuinely shrinks (e.g., user deleted a merged
+ * PR reference remotely) cannot be decremented via this path — but that is
+ * a rare case, and the alternative is silent decay of historical analytics.
  */
 export declare function mergeMonthlyCounts(existing: Record<string, number>, fresh: Record<string, number>): Record<string, number>;
 /**
@@ -80,6 +95,15 @@ export interface DashboardFetchResult {
     commentedIssues: CommentedIssue[];
     allMergedPRs: MergedPR[];
     allClosedPRs: ClosedPR[];
+    /**
+     * Labels of non-critical sub-fetches that degraded to empty fallbacks
+     * during this run. Empty array means every fetch succeeded. Non-empty
+     * means one or more slices of the returned data are approximations —
+     * callers surface this to the user so "0 recently merged" does not look
+     * authoritative when it is actually "fetch failed, fell back to empty".
+     * See #1035.
+     */
+    partialFailures: string[];
 }
 /**
  * Fetch fresh dashboard data from GitHub.