@oss-autopilot/core 3.12.0 → 3.13.1

package/dist/commands/dashboard-data.js

@@ -3,7 +3,7 @@
  * Handles GitHub API calls, PR grouping, stats computation, and monthly chart data.
  * Consumed by the dashboard HTTP server (dashboard-server.ts) for the SPA API.
  */
-import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit, CRITICAL_STATUSES } from '../core/index.js';
+import { getStateManager, PRMonitor, IssueConversationMonitor, getOctokit, CRITICAL_STATUSES, applyStatusOverrides, } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult, fetchMergedPRsSince, fetchClosedPRsSince } from '../core/github-stats.js';
@@ -236,6 +236,13 @@ export async function fetchDashboardData(token) {
     // try-catch: save errors should not crash the dashboard data fetch.
     try {
         stateManager.batch(() => {
+            // Apply status overrides BEFORE partitioning, mirroring the daily check
+            // (daily.ts partitions overriddenPRs). Partitioning on raw status let a
+            // dormant PR with a criticality-flipping override land in a different
+            // partition here than on the CLI surface (#1416). Inside the batch
+            // because getStatusOverride may auto-clear stale overrides with a save,
+            // which must defer to this guarded boundary rather than throw here.
+            const overriddenPRs = applyStatusOverrides(prs, stateManager.getState());
             // Store new merged PRs incrementally (dedupes by URL)
             try {
                 const { dropped } = stateManager.addMergedPRs(newMergedPRs);
@@ -256,20 +263,30 @@ export async function fetchDashboardData(token) {
             catch (error) {
                 warn(MODULE, `Failed to store closed PRs: ${errorMessage(error)}`);
             }
-            // Store monthly chart data (opened/merged/closed) so charts have data
+            // Store monthly chart data (opened/merged/closed) so charts have data.
+            // Analytics intentionally consume RAW prs: overrides only change status,
+            // never the createdAt/mergedAt dates the monthly counts key off.
             const { monthlyCounts, monthlyOpenedCounts: openedFromMerged } = mergedResult;
             const { monthlyCounts: monthlyClosedCounts, monthlyOpenedCounts: openedFromClosed } = closedResult;
             updateMonthlyAnalytics(prs, monthlyCounts, monthlyClosedCounts, openedFromMerged, openedFromClosed);
+            // The digest keeps RAW statuses in openPRs: this digest becomes the
+            // server's cached/persisted rebuild source, and baking overridden
+            // statuses into it would make CLEARING an override (move target=auto) a
+            // silent no-op until the next full refresh — buildDashboardJson can
+            // only apply overrides that still exist, never un-apply baked ones. It
+            // re-applies live overrides per request before partitioning.
             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, and a
             // critical PR is never display-shelved (#1352) — mirrors the daily
             // check's CRITICAL_STATUSES auto-unshelve so headline counts agree.
+            // Partitioned over overriddenPRs (#1416): the shelve decision must use
+            // the same post-override status the CLI partitions on.
             const shelvedUrls = new Set(stateManager.getState().config.shelvedPRUrls || []);
-            const freshShelved = prs.filter((pr) => !CRITICAL_STATUSES.has(pr.status) && (shelvedUrls.has(pr.url) || pr.stalenessTier === 'dormant'));
+            const freshShelved = overriddenPRs.filter((pr) => !CRITICAL_STATUSES.has(pr.status) && (shelvedUrls.has(pr.url) || pr.stalenessTier === 'dormant'));
             digest.shelvedPRs = freshShelved.map(toShelvedPRRef);
             digest.autoUnshelvedPRs = [];
-            digest.summary.totalActivePRs = prs.length - freshShelved.length;
+            digest.summary.totalActivePRs = overriddenPRs.length - freshShelved.length;
             stateManager.setLastDigest(digest);
         });
     }

package/dist/commands/dashboard-server.js

@@ -9,7 +9,7 @@ import * as http from 'node:http';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as crypto from 'node:crypto';
-import { getStateManager, getGitHubToken, getCLIVersion, applyStatusOverrides, classifyAttentionBucket, } from '../core/index.js';
+import { getStateManager, getGitHubToken, getCLIVersion, applyStatusOverrides, classifyAttentionBucket, maybeCheckpoint, } from '../core/index.js';
 import { errorMessage, ValidationError, ConcurrencyError, GistConcurrencyError } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { validateUrl, validateGitHubUrl, PR_URL_PATTERN, ISSUE_URL_PATTERN } from './validation.js';
@@ -75,12 +75,23 @@ function getIssueListMtimeMs() {
  * start-up, so tests that need a specific digest should call this directly).
  */
 export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs, 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),
+        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(digest, state);
-    const prsByRepo = computePRsByRepo(digest, state);
+    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)
@@ -92,7 +103,7 @@ export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs,
     const isAboveMinStars = (pr) => !isBelowMinStars(repoScores[pr.repo]?.stargazersCount, minStars);
     const filteredMergedPRs = mergedPRs.filter(isAboveMinStars);
     const filteredClosedPRs = closedPRs.filter(isAboveMinStars);
-    const stats = buildDashboardStats(digest, state, filteredMergedPRs.length, filteredClosedPRs.length);
+    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
@@ -115,7 +126,10 @@ export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs,
         monthlyClosed,
         // #1352: stamp the unified attention bucket so the SPA renders the same
         // taxonomy the CLI brief counts (single classifier, no second opinion).
-        activePRs: applyStatusOverrides(digest.openPRs || [], state).map((pr) => ({
+        // 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),
         })),
@@ -123,10 +137,10 @@ export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs,
         // 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: (digest.shelvedPRs || []).map((ref) => ref.url),
-        recentlyMergedPRs: digest.recentlyMergedPRs || [],
-        recentlyClosedPRs: digest.recentlyClosedPRs || [],
-        autoUnshelvedPRs: digest.autoUnshelvedPRs || [],
+        shelvedPRUrls: (overriddenDigest.shelvedPRs || []).map((ref) => ref.url),
+        recentlyMergedPRs: overriddenDigest.recentlyMergedPRs || [],
+        recentlyClosedPRs: overriddenDigest.recentlyClosedPRs || [],
+        autoUnshelvedPRs: overriddenDigest.autoUnshelvedPRs || [],
         commentedIssues,
         issueResponses,
         allMergedPRs: filteredMergedPRs,
@@ -296,11 +310,46 @@ export async function startDashboardServer(options) {
     // not disappear when /api/data rebuilds after a state change or after a
     // POST /api/action completes.
     let cachedPartialFailures = undefined;
+    // Gist checkpoint warnings from dashboard mutations (#1417). DELIBERATELY
+    // separate from cachedPartialFailures: fetch failures clear on a successful
+    // PULL, but a gist-sync warning means an un-pushed mutation, and a pull is
+    // exactly the event that can destroy it (refreshFromGist wholesale-replaces
+    // state). These clear only when a checkpoint PUSH succeeds.
+    let pendingGistSyncWarnings = [];
     // 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.
     let lastBackgroundRefreshError = null;
+    /** Record a mutation's checkpoint outcome. `null` means the push succeeded
+     * (or local mode) — and a successful push carries the FULL current state,
+     * so any previously pending warning is resolved with it. */
+    function recordGistSyncOutcome(warning) {
+        if (warning === null) {
+            pendingGistSyncWarnings = [];
+            return;
+        }
+        if (!pendingGistSyncWarnings.includes(warning)) {
+            pendingGistSyncWarnings.push(warning);
+        }
+    }
+    /** Merge pending gist-sync warnings into a partialFailures payload for the
+     * SPA banner without coupling their lifecycles. */
+    function withPendingGistWarnings(failures) {
+        if (pendingGistSyncWarnings.length === 0)
+            return failures;
+        const base = failures ?? [];
+        return [...base, ...pendingGistSyncWarnings.filter((w) => !base.includes(w))];
+    }
+    /** Push-before-pull (#1417): an un-pushed mutation would be silently
+     * reverted by the next Gist pull. Retry the checkpoint first so a recovered
+     * network turns the pending warning into a real push before any pull runs.
+     * No-op when nothing is pending. */
+    async function flushPendingGistSync() {
+        if (pendingGistSyncWarnings.length === 0)
+            return;
+        recordGistSyncOutcome(await maybeCheckpoint(stateManager, MODULE));
+    }
     if (!cachedDigest) {
         throw new Error('No dashboard data available. Run the daily check first: GITHUB_TOKEN=$(gh auth token) npm start -- daily');
     }
@@ -308,7 +357,7 @@ export async function startDashboardServer(options) {
     let cachedJsonData;
     let cachedIssueListMtimeMs = getIssueListMtimeMs();
     try {
-        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, cachedPartialFailures);
+        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, withPendingGistWarnings(cachedPartialFailures));
     }
     catch (error) {
         throw new Error(`Failed to build dashboard data: ${errorMessage(error)}. State data may be corrupted — try running: daily --json`, { cause: error });
@@ -343,6 +392,7 @@ export async function startDashboardServer(options) {
                 // Re-read state if modified externally (file mtime for local, Gist API for Gist mode)
                 let stateChanged = false;
                 if (stateManager.isGistMode()) {
+                    await flushPendingGistSync();
                     stateChanged = await stateManager.refreshFromGist();
                 }
                 else {
@@ -353,7 +403,7 @@ export async function startDashboardServer(options) {
                 const issueListChanged = currentIssueListMtimeMs !== cachedIssueListMtimeMs;
                 if (stateChanged || issueListChanged) {
                     try {
-                        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, cachedPartialFailures);
+                        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, withPendingGistWarnings(cachedPartialFailures));
                         cachedIssueListMtimeMs = currentIssueListMtimeMs;
                     }
                     catch (error) {
@@ -432,6 +482,7 @@ export async function startDashboardServer(options) {
     /** Re-read state written by external processes (CLI) before mutating. */
     async function reloadState() {
         if (stateManager.isGistMode()) {
+            await flushPendingGistSync();
             await stateManager.refreshFromGist();
         }
         else {
@@ -475,6 +526,11 @@ export async function startDashboardServer(options) {
         }
         // Resolve the mutation up-front so target validation happens before the
         // state reload — keeps the reload-to-save freshness window minimal.
+        // Each mutation records the Gist checkpoint outcome (#1417): in gist mode
+        // `save()` only writes the local cache, and an un-pushed mutation can be
+        // wholesale-reverted by the next successful refreshFromGist — so a failed
+        // push must reach the SPA, not vanish into a discarded return value.
+        let gistSyncWarning = null;
         let applyMutation;
         if (body.action === 'move') {
             const { VALID_TARGETS, runMove } = await import('./move.js');
@@ -484,13 +540,18 @@ export async function startDashboardServer(options) {
             }
             const target = body.target;
             applyMutation = async () => {
-                await runMove({ prUrl: body.url, target });
+                const output = await runMove({ prUrl: body.url, target });
+                gistSyncWarning = output.gistSyncWarning ?? null;
             };
         }
         else {
             // dismiss_issue_response
-            applyMutation = () => {
+            applyMutation = async () => {
                 stateManager.dismissIssue(body.url, new Date().toISOString());
+                // Mirror runMove's contract: every mutating surface checkpoints to
+                // Gist and surfaces the warning. Never throws — failures come back
+                // as the warning string.
+                gistSyncWarning = await maybeCheckpoint(stateManager, MODULE);
             };
         }
         // Reload state before mutating to avoid overwriting external CLI changes.
@@ -530,11 +591,16 @@ export async function startDashboardServer(options) {
                 return;
             }
         }
+        // Surface the checkpoint outcome through the partialFailures banner the
+        // SPA already renders (#1417). Tracked in pendingGistSyncWarnings — NOT
+        // cachedPartialFailures — because gist warnings clear on a successful
+        // PUSH, while fetch failures clear on a successful pull/refresh.
+        recordGistSyncOutcome(gistSyncWarning);
         // Rebuild dashboard data from cached digest + updated state. Persist
         // the last-known partialFailures across action rebuilds (#1035) so the
         // SPA banner survives user interactions until the next successful
         // refresh clears it.
-        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, cachedPartialFailures);
+        cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, undefined, undefined, withPendingGistWarnings(cachedPartialFailures));
         cachedIssueListMtimeMs = getIssueListMtimeMs();
         sendJson(res, 200, cachedJsonData);
     }
@@ -554,7 +620,7 @@ export async function startDashboardServer(options) {
             // Update the persistent banner signal — clear on a clean refresh,
             // set when one or more sub-fetches degraded. See #1035.
             cachedPartialFailures = result.partialFailures.length > 0 ? result.partialFailures : undefined;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs, cachedPartialFailures);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs, withPendingGistWarnings(cachedPartialFailures));
             cachedIssueListMtimeMs = getIssueListMtimeMs();
             sendJson(res, 200, cachedJsonData);
         }
@@ -675,6 +741,7 @@ export async function startDashboardServer(options) {
         fetchDashboardData(token)
             .then(async (result) => {
             if (stateManager.isGistMode()) {
+                await flushPendingGistSync();
                 await stateManager.refreshFromGist();
             }
             else {
@@ -683,7 +750,7 @@ export async function startDashboardServer(options) {
             cachedDigest = result.digest;
             cachedCommentedIssues = result.commentedIssues;
             cachedPartialFailures = result.partialFailures.length > 0 ? result.partialFailures : undefined;
-            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs, cachedPartialFailures);
+            cachedJsonData = buildDashboardJson(cachedDigest, stateManager.getState(), cachedCommentedIssues, result.allMergedPRs, result.allClosedPRs, withPendingGistWarnings(cachedPartialFailures));
             cachedIssueListMtimeMs = getIssueListMtimeMs();
             // Successful refresh clears any prior failure signal (#1205).
             lastBackgroundRefreshError = null;

package/dist/commands/features.js

@@ -52,7 +52,11 @@ function toFeaturesCandidate(scoutCandidate, getState) {
     // this repo" rather than a fabricated score.
     const grade = gradeFromCandidate({
         repo: scoutCandidate.issue.repo,
-        projectHealth: { avgIssueResponseDays: null, daysSinceLastCommit: null, checkFailed: true },
+        projectHealth: {
+            repo: scoutCandidate.issue.repo,
+            checkFailed: true,
+            failureReason: 'health not fetched on the multi-issue feature surface',
+        },
         getRepoScore: (repo) => {
             const score = getState.getRepoScore(repo);
             return score

package/dist/commands/list-mark-done.d.ts

@@ -1,6 +1,9 @@
 /**
  * list-mark-done command (#1299).
  *
+ * A URL that is not in the list at all is an error (#1406) — marking done
+ * requires an existing entry; only the already-marked re-run is a quiet no-op.
+ *
  * Mark an issue line in a curated list as done by wrapping it in
  * `~~strikethrough~~` and appending a `**Done** — PR [#N](url) ...` sub-bullet.
  * If every issue under the same `### repo/name` heading is now struck through,
@@ -19,7 +22,8 @@ export interface MarkDoneOptions {
     listPath: string;
 }
 export interface MarkDoneOutput {
-    /** True if the line was found and updated. False on already-marked or not-found. */
+    /** True if the line was found and updated. False only when already marked
+     * done — a URL missing from the list entirely throws instead (#1406). */
     marked: boolean;
     /** Fully-resolved file path that was inspected. */
     filePath: string;
@@ -32,6 +36,8 @@ export interface MarkDoneOutput {
     /** Human-readable explanation when `marked` is false. */
     reason?: string;
 }
+/** Discriminates the two `marked: false` outcomes of {@link markIssueAsDone}. */
+export type MarkDoneNoOpReason = 'not-found' | 'already-marked';
 /** Pure transform — exposed for unit testing. */
 export declare function markIssueAsDone(content: string, opts: {
     issueUrl: string;
@@ -43,6 +49,8 @@ export declare function markIssueAsDone(content: string, opts: {
     repoHeadingStruck: boolean;
     remainingUnderRepo: number;
     reason?: string;
+    /** Set only when `marked` is false — why nothing changed. */
+    reasonCode?: MarkDoneNoOpReason;
 };
 /** Read → transform → write atomically (tmp + rename) so a crash mid-write can't corrupt the file. */
 export declare function runMarkIssueListItemDone(options: MarkDoneOptions): Promise<MarkDoneOutput>;

package/dist/commands/list-mark-done.js

@@ -1,6 +1,9 @@
 /**
  * list-mark-done command (#1299).
  *
+ * A URL that is not in the list at all is an error (#1406) — marking done
+ * requires an existing entry; only the already-marked re-run is a quiet no-op.
+ *
  * Mark an issue line in a curated list as done by wrapping it in
  * `~~strikethrough~~` and appending a `**Done** — PR [#N](url) ...` sub-bullet.
  * If every issue under the same `### repo/name` heading is now struck through,
@@ -13,7 +16,7 @@
  */
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { errorMessage } from '../core/errors.js';
+import { errorMessage, ValidationError } from '../core/errors.js';
 const STRIKE = '~~';
 const DONE_PREFIX = '  - **Done**';
 const ISSUE_LINE_RE = /^[*+-]\s/;
@@ -113,6 +116,7 @@ export function markIssueAsDone(content, opts) {
             repoHeadingStruck: false,
             remainingUnderRepo: 0,
             reason: 'issue URL not found in the list',
+            reasonCode: 'not-found',
         };
     }
     const issueLine = lines[block.start];
@@ -126,6 +130,7 @@ export function markIssueAsDone(content, opts) {
             repoHeadingStruck: false,
             remainingUnderRepo: section ? countOpenIssues(lines, section) : 0,
             reason: 'already marked done',
+            reasonCode: 'already-marked',
         };
     }
     // 1. Strike the issue line.
@@ -186,6 +191,14 @@ export async function runMarkIssueListItemDone(options) {
         prUrl: options.prUrl,
         prStatus: options.prStatus,
     });
+    // #1406: a missing entry is a caller error, not a quiet success — the
+    // consumer branch in workflows/draft-first-workflow.md already documents
+    // this contract (STOP on success:false mentioning "Issue URL not found").
+    // Idempotent re-runs (already marked done) still resolve normally.
+    if (result.reasonCode === 'not-found') {
+        throw new ValidationError(`Issue URL not found in the list: ${options.issueUrl} (${filePath}). ` +
+            'Check the URL and --list-path; the entry must exist before it can be marked done.');
+    }
     if (result.marked) {
         const tmp = `${filePath}.tmp-${process.pid}-${Date.now()}`;
         try {

package/dist/commands/scout-bridge.js

@@ -90,8 +90,20 @@ export function buildScoutState() {
             // `--split-ratio` flags for overrides.
             featuresAnchorThreshold: 3,
             featuresSplitRatio: 0.6,
+            // Personalization-bias prefs, likewise required on the inferred type
+            // (scout #1244 / #168). Autopilot doesn't surface these as settings yet,
+            // so we pass scout's documented "no bias" defaults.
+            preferLanguages: [],
+            preferRepos: [],
+            diversityRatio: 0,
+            avoidRepos: [],
+            boostIssueTypes: [],
         },
         repoScores: state.repoScores,
+        // Scout #117 added tombstones (deletion records for gist merge). Autopilot
+        // synthesizes a fresh ScoutState per operation and tracks no deletions, so
+        // an empty list is correct here.
+        tombstones: [],
         starredRepos: config.starredRepos,
         starredReposLastFetched: config.starredReposLastFetched,
         mergedPRs: (state.mergedPRs ?? []).map((pr) => ({

package/dist/commands/search.d.ts

@@ -10,6 +10,14 @@ export { type SearchOutput } from '../formatters/json.js';
  * lands in one place instead of three (#1002).
  */
 export declare const MAX_SEARCH_RESULTS = 100;
+/**
+ * Fraction of search slots reserved for candidates that matched neither
+ * strategy-preferred languages nor repos (#1244). Counterweight against
+ * echo-chamber bias: without it, strategy-boosted searches return more of
+ * what already merged, which merges more of the same, and the profile
+ * narrows over time. Scout clamps to [0, 1]; 0.2 is the issue's proposal.
+ */
+export declare const SEARCH_DIVERSITY_RATIO = 0.2;
 interface SearchOptions {
     maxResults: number;
 }

package/dist/commands/search.js

@@ -14,6 +14,14 @@ const MODULE = 'search';
  * lands in one place instead of three (#1002).
  */
 export const MAX_SEARCH_RESULTS = 100;
+/**
+ * Fraction of search slots reserved for candidates that matched neither
+ * strategy-preferred languages nor repos (#1244). Counterweight against
+ * echo-chamber bias: without it, strategy-boosted searches return more of
+ * what already merged, which merges more of the same, and the profile
+ * narrows over time. Scout clamps to [0, 1]; 0.2 is the issue's proposal.
+ */
+export const SEARCH_DIVERSITY_RATIO = 0.2;
 /**
  * Search GitHub for contributable issues using multi-phase discovery.
  *
@@ -63,6 +71,7 @@ export async function runSearch(options) {
         maxResults: options.maxResults,
         preferLanguages,
         preferRepos,
+        diversityRatio: SEARCH_DIVERSITY_RATIO,
     });
     // #1354: never surface issues the user already has an open PR for. Uses
     // scout's structured linked-PR metadata when present; candidates without it
@@ -88,7 +97,11 @@ export async function runSearch(options) {
             // before" rather than a fabricated score.
             const grade = gradeFromCandidate({
                 repo: c.issue.repo,
-                projectHealth: { avgIssueResponseDays: null, daysSinceLastCommit: null, checkFailed: true },
+                projectHealth: {
+                    repo: c.issue.repo,
+                    checkFailed: true,
+                    failureReason: 'health not fetched on the multi-issue search surface',
+                },
                 getRepoScore: (repo) => {
                     const score = stateManager.getRepoScore(repo);
                     return score
@@ -126,8 +139,14 @@ export async function runSearch(options) {
                     }
                     : undefined,
                 ...(linkedPR ? { linkedPR } : {}),
-                ...(typeof c.boostScore === 'number' ? { boostScore: c.boostScore } : {}),
-                ...(c.boostReasons && c.boostReasons.length > 0 ? { boostReasons: c.boostReasons } : {}),
+                // Scout 1.0 folded the boostScore/boostReasons/diversitySlot trio into a
+                // single `personalization` field (#158). Derive the flat output fields
+                // from it so this command's JSON shape is unchanged.
+                ...(c.personalization?.kind === 'boosted' ? { boostScore: c.personalization.score } : {}),
+                ...(c.personalization?.kind === 'boosted' && c.personalization.reasons.length > 0
+                    ? { boostReasons: c.personalization.reasons }
+                    : {}),
+                ...(c.personalization?.kind === 'diversity' ? { diversitySlot: true } : {}),
             };
         }),
         excludedRepos: result.excludedRepos,

package/dist/core/index.d.ts

@@ -8,7 +8,7 @@ export { guidelinesFilename, repoFromGuidelinesFilename, GUIDELINES_FILE_PREFIX,
 export { PRMonitor, type PRCheckFailure, type FetchPRsResult, computeDisplayLabel, classifyCICheck, classifyFailingChecks, } from './pr-monitor.js';
 export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
-export { wrapUntrustedContent, extractFromFence, safeExtractFromFence, UNTRUSTED_OPEN_TAG_NAME, UNTRUSTED_CLOSE_TAG, type UntrustedContentMeta, } from './untrusted-content.js';
+export { wrapUntrustedContent, fenceFetchedPR, extractFromFence, safeExtractFromFence, UNTRUSTED_OPEN_TAG_NAME, UNTRUSTED_CLOSE_TAG, type UntrustedContentMeta, } from './untrusted-content.js';
 export { getOctokit, checkRateLimit, type RateLimitInfo } from './github.js';
 export { parseGitHubUrl, splitRepo, isOwnRepo } from './urls.js';
 export { daysBetween, formatRelativeTime, byDateDescending } from './dates.js';

package/dist/core/index.js

@@ -9,7 +9,7 @@ export { PRMonitor, computeDisplayLabel, classifyCICheck, classifyFailingChecks,
 // Search/vetting now delegated to @oss-scout/core via commands/scout-bridge.ts
 export { IssueConversationMonitor } from './issue-conversation.js';
 export { isBotAuthor, isAcknowledgmentComment } from './comment-utils.js';
-export { wrapUntrustedContent, extractFromFence, safeExtractFromFence, UNTRUSTED_OPEN_TAG_NAME, UNTRUSTED_CLOSE_TAG, } from './untrusted-content.js';
+export { wrapUntrustedContent, fenceFetchedPR, extractFromFence, safeExtractFromFence, UNTRUSTED_OPEN_TAG_NAME, UNTRUSTED_CLOSE_TAG, } from './untrusted-content.js';
 export { getOctokit, checkRateLimit } from './github.js';
 export { parseGitHubUrl, splitRepo, isOwnRepo } from './urls.js';
 export { daysBetween, formatRelativeTime, byDateDescending } from './dates.js';

package/dist/core/issue-grading.d.ts

@@ -10,6 +10,7 @@
  * treated as a risk, not ignored). This matches the policy previously
  * described as prose in agents/issue-scout.md.
  */
+import type { ProjectHealth } from '@oss-scout/core';
 export type GradeLetter = 'A' | 'B' | 'C' | 'F';
 export interface GradeSignals {
     /** Average maintainer response time in days; null if unknown. */
@@ -61,11 +62,7 @@ export declare function deriveGradeSignals(params: {
  */
 export declare function gradeFromCandidate(params: {
     repo: string;
-    projectHealth: {
-        avgIssueResponseDays: number | null;
-        daysSinceLastCommit: number | null;
-        checkFailed?: boolean;
-    };
+    projectHealth: ProjectHealth;
     getRepoScore: (repo: string) => {
         mergedPRCount: number;
         closedWithoutMergeCount: number;

package/dist/core/issue-grading.js

@@ -103,8 +103,19 @@ export function deriveGradeSignals(params) {
  */
 export function gradeFromCandidate(params) {
     const repoScore = params.getRepoScore(params.repo);
+    // Narrow the union into the minimal shape deriveGradeSignals expects. The
+    // check-failed arm has no avgIssueResponseDays/daysSinceLastCommit, and the
+    // grader already treats checkFailed as untrusted (no snapshot signals).
+    const ph = params.projectHealth;
+    const projectHealth = ph.checkFailed
+        ? { avgIssueResponseDays: null, daysSinceLastCommit: null, checkFailed: true }
+        : {
+            avgIssueResponseDays: ph.avgIssueResponseDays,
+            daysSinceLastCommit: ph.daysSinceLastCommit,
+            checkFailed: false,
+        };
     return computeSuccessGrade(deriveGradeSignals({
-        projectHealth: params.projectHealth,
+        projectHealth,
         repoScore: repoScore
             ? {
                 mergedPRCount: repoScore.mergedPRCount,

package/dist/core/strategy.js

@@ -105,6 +105,25 @@ function recommendForOverExtension(openPRCount, dormantPRCount, overExtended) {
         return 'open_more';
     return null;
 }
+/**
+ * Read-only mirror of the status-override lookup (#1416): same staleness
+ * rule as `StateManager.getStatusOverride` (an override recorded against
+ * older activity than the PR's `updatedAt` is ignored), but with NO
+ * auto-clear write — this module stays pure/no-I/O, and the daily and
+ * dashboard pipelines own clearing stale overrides.
+ */
+function effectiveStatus(pr, state) {
+    if (typeof pr.url !== 'string')
+        return pr.status;
+    const override = state.config.statusOverrides?.[pr.url];
+    if (!override)
+        return pr.status;
+    if (typeof pr.updatedAt === 'string' && pr.updatedAt > override.lastActivityAt)
+        return pr.status;
+    if (override.status !== 'needs_addressing' && override.status !== 'waiting_on_maintainer')
+        return pr.status;
+    return override.status;
+}
 /**
  * Compute the deterministic strategy signal from agent state. Returns
  * null when state is thinner than {@link STRATEGY_MIN_PRS} merged PRs —
@@ -158,12 +177,20 @@ export function computeStrategy(state) {
     // Capacity: read from the last digest. When no digest exists yet,
     // default to zero (the agent has nothing to recommend without a
     // digest). The DailyDigest schema does not store a `dormantCount`
-    // directly — derive it from the `waitingOnMaintainerPRs` array,
-    // which is the "PR flagged as awaiting maintainer review" bucket
-    // produced by `pr-monitor`.
+    // directly — derive it from the "awaiting maintainer review" bucket.
+    //
+    // Status-basis reconciliation (#1416): dashboard-written digests keep RAW
+    // statuses in `openPRs` (so override CLEARS stay visible on rebuild) while
+    // `summary.totalActivePRs` is override-basis. Re-derive the waiting bucket
+    // from `openPRs` through the override map so both capacity inputs share
+    // one basis; fall back to the stored array for digests without `openPRs`
+    // (which daily.ts builds post-override anyway).
     const summary = state.lastDigest?.summary;
     const openPRCount = summary?.totalActivePRs ?? 0;
-    const waiting = state.lastDigest?.waitingOnMaintainerPRs ?? [];
+    const openPRs = (state.lastDigest?.openPRs ?? []);
+    const waiting = openPRs.length > 0
+        ? openPRs.filter((pr) => effectiveStatus(pr, state) === 'waiting_on_maintainer')
+        : (state.lastDigest?.waitingOnMaintainerPRs ?? []);
     const dormantPRCount = waiting.length;
     // Overextended: dormant PRs spread across 2+ repos. Same definition
     // the issue body uses.

package/dist/core/untrusted-content.d.ts

@@ -18,6 +18,9 @@
  *
  *  - `runComments` (commands/comments.ts): review / inline / discussion
  *    comment bodies in the `comments` CLI `--json` + MCP tool output.
+ *  - `deduplicateDigest` (formatters/json.ts) and the MCP PR resources:
+ *    `openPRs[].lastMaintainerComment.body` via {@link fenceFetchedPR}
+ *    (#1420).
  *  - `fetchPRCommentBundle` (core/pr-comments-fetcher.ts): bundle bodies
  *    feeding `guidelines fetch-corpus` (agent-only consumer).
  *  - `toDailyOutput` (commands/daily.ts): `commentedIssues[].lastResponseBody`
@@ -67,3 +70,24 @@ export declare function extractFromFence(fenced: string): string;
  * never throws.
  */
 export declare function safeExtractFromFence(text: string): string;
+/**
+ * Fence the attacker-controllable maintainer-comment excerpt on a FetchedPR
+ * for agent-facing serialization (#1420). Applied at the serialization
+ * boundary (daily/startup --json via deduplicateDigest, MCP PR resources)
+ * rather than at fetch time: extractMaintainerActionHints parses the RAW
+ * body inside the pipeline, and human surfaces (dashboard SPA, CLI text
+ * mode) must not render fence markup. Returns a copy; never mutates.
+ */
+export declare function fenceFetchedPR<T extends FenceablePR>(pr: T): T;
+/** Structural slice of FetchedPR that {@link fenceFetchedPR} needs — kept
+ * structural to avoid an import cycle with types.ts consumers. */
+interface FenceablePR {
+    repo: string;
+    number: number;
+    lastMaintainerComment?: {
+        author: string;
+        body: string;
+        createdAt: string;
+    };
+}
+export {};