@oss-autopilot/core 3.6.0 → 3.7.0

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

@@ -7,6 +7,13 @@ export interface LaunchResult {
     url: string;
     port: number;
     alreadyRunning: boolean;
+    /**
+     * When `alreadyRunning` is true, the timestamp the running server most
+     * recently recorded a browser-open at (or undefined if never recorded).
+     * Used by startup to throttle duplicate browser tabs across `/oss` runs.
+     * Always undefined for fresh launches.
+     */
+    lastBrowserOpenedAt?: string;
 }
 /**
  * Launch the interactive dashboard SPA server as a detached background process.

package/dist/commands/dashboard-lifecycle.js

@@ -61,12 +61,22 @@ export async function launchDashboardServer(options) {
             else {
                 // Could not kill old server (e.g. EPERM); return it rather than
                 // attempting a doomed spawn on the same port.
-                return { url: existing.url, port: existing.port, alreadyRunning: true };
+                return {
+                    url: existing.url,
+                    port: existing.port,
+                    alreadyRunning: true,
+                    lastBrowserOpenedAt: info?.lastBrowserOpenedAt,
+                };
             }
             // Fall through to launch a new server
         }
         else {
-            return { url: existing.url, port: existing.port, alreadyRunning: true };
+            return {
+                url: existing.url,
+                port: existing.port,
+                alreadyRunning: true,
+                lastBrowserOpenedAt: info.lastBrowserOpenedAt,
+            };
         }
     }
     // 3. Launch as detached child process

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

@@ -7,10 +7,18 @@ export interface DashboardServerInfo {
     port: number;
     startedAt: string;
     version?: string;
+    lastBrowserOpenedAt?: string;
 }
 export declare function getDashboardPidPath(): string;
 export declare function writeDashboardServerInfo(info: DashboardServerInfo): void;
 export declare function readDashboardServerInfo(): DashboardServerInfo | null;
+/**
+ * Stamp the PID file with the current time as `lastBrowserOpenedAt`. Used by
+ * startup to throttle re-opening the dashboard tab — see the `shouldOpenBrowser`
+ * helper in `startup.ts`. No-ops if the PID file is missing or the recorded
+ * port doesn't match (server may have restarted between read and write).
+ */
+export declare function recordBrowserOpened(port: number): void;
 export declare function removeDashboardServerInfo(): void;
 export declare function isDashboardServerRunning(port: number): Promise<boolean>;
 export declare function findRunningDashboardServer(): Promise<{

package/dist/commands/dashboard-process.js

@@ -29,6 +29,9 @@ export function readDashboardServerInfo() {
             warn(MODULE, 'PID file has invalid structure, ignoring');
             return null;
         }
+        if (parsed.lastBrowserOpenedAt !== undefined && typeof parsed.lastBrowserOpenedAt !== 'string') {
+            delete parsed.lastBrowserOpenedAt;
+        }
         return parsed;
     }
     catch (err) {
@@ -39,6 +42,23 @@ export function readDashboardServerInfo() {
         return null;
     }
 }
+/**
+ * Stamp the PID file with the current time as `lastBrowserOpenedAt`. Used by
+ * startup to throttle re-opening the dashboard tab — see the `shouldOpenBrowser`
+ * helper in `startup.ts`. No-ops if the PID file is missing or the recorded
+ * port doesn't match (server may have restarted between read and write).
+ */
+export function recordBrowserOpened(port) {
+    const info = readDashboardServerInfo();
+    if (!info || info.port !== port)
+        return;
+    try {
+        writeDashboardServerInfo({ ...info, lastBrowserOpenedAt: new Date().toISOString() });
+    }
+    catch (err) {
+        warn(MODULE, `Failed to record browser-opened timestamp: ${err.message}`);
+    }
+}
 export function removeDashboardServerInfo() {
     try {
         fs.unlinkSync(getDashboardPidPath());

package/dist/commands/features.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Features command (scout 0.9.0 #97/#98/#99)
+ *
+ * Wraps `scout.features()` to surface feature-scoped contribution
+ * opportunities in repos where the user already has 3+ merged PRs
+ * (configurable via `featuresAnchorThreshold`). Returns two ranked
+ * buckets — "quick wins" and "bigger bets" — split by maintainer-
+ * commitment signals (milestones, roadmap membership, label set).
+ *
+ * Mirrors the shape of `runSearch`: each bucket entry is a
+ * {@link SearchCandidate} augmented with a `horizon` literal so callers
+ * can render bucket-specific UX while reusing the search candidate
+ * formatter.
+ */
+import { type FeaturesOutput } from '../formatters/json.js';
+export { type FeaturesOutput, type FeaturesCandidate } from '../formatters/json.js';
+/**
+ * Hard cap on feature-search result count, matching `MAX_SEARCH_RESULTS`
+ * for `runSearch`. Shared between CLI (`cli-registry.ts`) and the MCP
+ * tool registration so a future adjustment lands in one place.
+ */
+export declare const MAX_FEATURES_RESULTS = 100;
+interface FeaturesOptions {
+    maxResults: number;
+    /** Override `featuresAnchorThreshold` for this call (1-50). */
+    anchorThreshold?: number;
+    /** Override `featuresSplitRatio` for this call (0-1). */
+    splitRatio?: number;
+}
+/**
+ * Run feature-scoped contribution discovery via `scout.features()`.
+ *
+ * @param options - Feature search configuration
+ * @param options.maxResults - Total candidates returned across both buckets
+ * @param options.anchorThreshold - Optional per-call override for the merged-PR threshold (default: scout's `featuresAnchorThreshold`)
+ * @param options.splitRatio - Optional per-call override for the quick-win split ratio (default: scout's `featuresSplitRatio`)
+ * @returns Two ranked buckets (quick-wins / bigger-bets) plus anchor list and an optional human message
+ * @throws {ConfigurationError} If no GitHub token is available
+ *
+ * @example
+ * ```typescript
+ * import { runFeatures } from '@oss-autopilot/core/commands';
+ *
+ * const result = await runFeatures({ maxResults: 10 });
+ * for (const c of [...result.quickWins, ...result.biggerBets]) {
+ *   console.log(`${c.issue.repo}#${c.issue.number} — ${c.horizon}`);
+ * }
+ * ```
+ */
+export declare function runFeatures(options: FeaturesOptions): Promise<FeaturesOutput>;

package/dist/commands/features.js

@@ -0,0 +1,131 @@
+/**
+ * Features command (scout 0.9.0 #97/#98/#99)
+ *
+ * Wraps `scout.features()` to surface feature-scoped contribution
+ * opportunities in repos where the user already has 3+ merged PRs
+ * (configurable via `featuresAnchorThreshold`). Returns two ranked
+ * buckets — "quick wins" and "bigger bets" — split by maintainer-
+ * commitment signals (milestones, roadmap membership, label set).
+ *
+ * Mirrors the shape of `runSearch`: each bucket entry is a
+ * {@link SearchCandidate} augmented with a `horizon` literal so callers
+ * can render bucket-specific UX while reusing the search candidate
+ * formatter.
+ */
+import { buildCandidateLinkedPR, createAutopilotScout } from './scout-bridge.js';
+import { getStateManager } from '../core/index.js';
+import { gradeFromCandidate } from '../core/issue-grading.js';
+import { warn } from '../core/logger.js';
+const MODULE = 'features';
+/**
+ * Hard cap on feature-search result count, matching `MAX_SEARCH_RESULTS`
+ * for `runSearch`. Shared between CLI (`cli-registry.ts`) and the MCP
+ * tool registration so a future adjustment lands in one place.
+ */
+export const MAX_FEATURES_RESULTS = 100;
+/**
+ * Coerce scout's raw `viabilityScore` into a trustworthy 0-100 number.
+ * Same defensive boundary check as `runSearch` — kept inline (not
+ * imported) so this command remains self-contained per the existing
+ * autopilot convention. See #1043.
+ */
+function sanitizeViabilityScore(raw) {
+    if (typeof raw !== 'number' || !Number.isFinite(raw) || raw < 0 || raw > 100) {
+        warn(MODULE, `Ignoring out-of-contract viabilityScore from scout: ${JSON.stringify(raw)}`);
+        return 0;
+    }
+    return raw;
+}
+/**
+ * Map one scout `FeatureCandidate` into the autopilot output shape.
+ * Mirrors the candidate-mapping branch in `runSearch` and stamps the
+ * `horizon` field.
+ */
+function toFeaturesCandidate(scoutCandidate, getState) {
+    const repoScoreRecord = getState.getRepoScore(scoutCandidate.issue.repo);
+    // Same `checkFailed: true` sentinel `runSearch` uses — scout's `features`
+    // pipeline reuses the same vetting code that does emit projectHealth on
+    // `vetIssue`, but on this surface scout returns the multi-issue list view
+    // which today does not propagate per-candidate health into IssueCandidate.
+    // Treating health as unknown grades from the autopilot-tracked repoScore
+    // alone, falling to 'F' for unfamiliar repos — an honest "we haven't seen
+    // this repo" rather than a fabricated score.
+    const grade = gradeFromCandidate({
+        repo: scoutCandidate.issue.repo,
+        projectHealth: { avgIssueResponseDays: null, daysSinceLastCommit: null, checkFailed: true },
+        getRepoScore: (repo) => {
+            const score = getState.getRepoScore(repo);
+            return score
+                ? {
+                    mergedPRCount: score.mergedPRCount,
+                    closedWithoutMergeCount: score.closedWithoutMergeCount,
+                    avgResponseDays: score.avgResponseDays ?? null,
+                }
+                : undefined;
+        },
+    });
+    const linkedPR = buildCandidateLinkedPR(scoutCandidate.vettingResult?.linkedPR);
+    return {
+        issue: {
+            repo: scoutCandidate.issue.repo,
+            repoUrl: `https://github.com/${scoutCandidate.issue.repo}`,
+            number: scoutCandidate.issue.number,
+            title: scoutCandidate.issue.title,
+            url: scoutCandidate.issue.url,
+            labels: scoutCandidate.issue.labels,
+        },
+        recommendation: scoutCandidate.recommendation,
+        reasonsToApprove: scoutCandidate.reasonsToApprove,
+        reasonsToSkip: scoutCandidate.reasonsToSkip,
+        searchPriority: scoutCandidate.searchPriority,
+        viabilityScore: sanitizeViabilityScore(scoutCandidate.viabilityScore),
+        grade,
+        repoScore: repoScoreRecord
+            ? {
+                score: repoScoreRecord.score,
+                mergedPRCount: repoScoreRecord.mergedPRCount,
+                closedWithoutMergeCount: repoScoreRecord.closedWithoutMergeCount,
+                isResponsive: repoScoreRecord.signals?.isResponsive ?? false,
+                lastMergedAt: repoScoreRecord.lastMergedAt,
+            }
+            : undefined,
+        ...(linkedPR ? { linkedPR } : {}),
+        horizon: scoutCandidate.horizon,
+    };
+}
+/**
+ * Run feature-scoped contribution discovery via `scout.features()`.
+ *
+ * @param options - Feature search configuration
+ * @param options.maxResults - Total candidates returned across both buckets
+ * @param options.anchorThreshold - Optional per-call override for the merged-PR threshold (default: scout's `featuresAnchorThreshold`)
+ * @param options.splitRatio - Optional per-call override for the quick-win split ratio (default: scout's `featuresSplitRatio`)
+ * @returns Two ranked buckets (quick-wins / bigger-bets) plus anchor list and an optional human message
+ * @throws {ConfigurationError} If no GitHub token is available
+ *
+ * @example
+ * ```typescript
+ * import { runFeatures } from '@oss-autopilot/core/commands';
+ *
+ * const result = await runFeatures({ maxResults: 10 });
+ * for (const c of [...result.quickWins, ...result.biggerBets]) {
+ *   console.log(`${c.issue.repo}#${c.issue.number} — ${c.horizon}`);
+ * }
+ * ```
+ */
+export async function runFeatures(options) {
+    const scout = await createAutopilotScout();
+    const result = await scout.features({
+        count: options.maxResults,
+        anchorThreshold: options.anchorThreshold,
+        splitRatio: options.splitRatio,
+    });
+    const stateManager = getStateManager();
+    const featuresOutput = {
+        quickWins: result.quickWins.map((c) => toFeaturesCandidate(c, stateManager)),
+        biggerBets: result.biggerBets.map((c) => toFeaturesCandidate(c, stateManager)),
+        anchorRepos: result.anchorRepos,
+        message: result.message,
+    };
+    return featuresOutput;
+}

package/dist/commands/index.d.ts

@@ -23,6 +23,8 @@ export { runStartup } from './startup.js';
 export { runStatus } from './status.js';
 /** Search GitHub for contributable issues using multi-strategy discovery. */
 export { runSearch, MAX_SEARCH_RESULTS } from './search.js';
+/** Surface feature-scoped opportunities in repos with 3+ merged PRs (scout 0.9.0). */
+export { runFeatures, MAX_FEATURES_RESULTS } from './features.js';
 /** Vet a single GitHub issue for claimability (open, unassigned, no linked PRs, repo health). */
 export { runVet } from './vet.js';
 /** Re-vet all available issues in a curated issue list for freshness. */
@@ -87,7 +89,7 @@ export { runDetectFormatters } from './detect-formatters.js';
 export { runLocalRepos } from './local-repos.js';
 export type { DashboardJsonData, DashboardStats, DashboardActionType, ActionRequest } from './dashboard-data.js';
 export type { ErrorCode } from '../formatters/json.js';
-export type { DailyOutput, SearchOutput, StartupOutput, StatusOutput, TrackOutput } from '../formatters/json.js';
+export type { DailyOutput, SearchOutput, SearchCandidate, CandidateLinkedPR, FeaturesOutput, FeaturesCandidate, FeaturesHorizon, StartupOutput, StatusOutput, TrackOutput, } from '../formatters/json.js';
 export type { VetOutput, CommentsOutput, PostOutput, ClaimOutput, VetListOutput, VetListItemStatus, } from '../formatters/json.js';
 export type { ConfigOutput, DetectFormattersOutput, ParseIssueListOutput, ParsedIssueItem, CheckIntegrationOutput, LocalReposOutput, } from '../formatters/json.js';
 export type { ShelveOutput, UnshelveOutput } from './shelve.js';

package/dist/commands/index.js

@@ -24,6 +24,8 @@ export { runStartup } from './startup.js';
 export { runStatus } from './status.js';
 /** Search GitHub for contributable issues using multi-strategy discovery. */
 export { runSearch, MAX_SEARCH_RESULTS } from './search.js';
+/** Surface feature-scoped opportunities in repos with 3+ merged PRs (scout 0.9.0). */
+export { runFeatures, MAX_FEATURES_RESULTS } from './features.js';
 /** Vet a single GitHub issue for claimability (open, unassigned, no linked PRs, repo health). */
 export { runVet } from './vet.js';
 /** Re-vet all available issues in a curated issue list for freshness. */

package/dist/commands/scout-bridge.d.ts

@@ -4,6 +4,7 @@
  */
 import { type LinkedPR as ScoutLinkedPR, type OssScout, type ScoutState } from '@oss-scout/core';
 import type { LinkedPR } from '../core/linked-pr-classification.js';
+import type { CandidateLinkedPR } from '../formatters/json.js';
 /**
  * Convert scout 0.6.0's `LinkedPR` (separate `state` + `merged`) into the
  * shape `classifyLinkedPR` expects (`state` already folded with `merged`).
@@ -12,8 +13,19 @@ import type { LinkedPR } from '../core/linked-pr-classification.js';
  * written before scout surfaced this data and uses a tri-state
  * `'open' | 'closed' | 'merged'` enum. Folding `merged` into the state
  * preserves the function's existing contract + tests.
+ *
+ * `updatedAt` (added in scout 0.9.0) flows through unchanged so consumers
+ * can hand the result to `isLinkedPRStalled` without re-fetching.
  */
 export declare function adaptScoutLinkedPR(scoutLinkedPR: ScoutLinkedPR | null | undefined): LinkedPR | null;
+/**
+ * Build the autopilot-shaped `linkedPR` slice consumed by `SearchOutput`,
+ * `VetOutput`, and `FeaturesOutput` from scout's raw `LinkedPR`
+ * (#97 / scout 0.9.0). Returns `undefined` when scout reported no linked
+ * PR. Computes `isStalled` from the adapted (autopilot-shape) PR so the
+ * rule stays consistent with `classifyLinkedPR` and downstream consumers.
+ */
+export declare function buildCandidateLinkedPR(scoutLinkedPR: ScoutLinkedPR | null | undefined): CandidateLinkedPR | undefined;
 /**
  * Build a ScoutState from the current AgentState.
  * Maps oss-autopilot's config and state fields to oss-scout's state format.

package/dist/commands/scout-bridge.js

@@ -3,7 +3,7 @@
  * Maps state fields and creates scout instances for search/vet commands.
  */
 import { createScout } from '@oss-scout/core';
-import { getStateManager, requireGitHubToken } from '../core/index.js';
+import { getStateManager, isLinkedPRStalled, requireGitHubToken } from '../core/index.js';
 import { loadSkippedIssues } from './skip-file-parser.js';
 /**
  * Convert scout 0.6.0's `LinkedPR` (separate `state` + `merged`) into the
@@ -13,14 +13,45 @@ import { loadSkippedIssues } from './skip-file-parser.js';
  * written before scout surfaced this data and uses a tri-state
  * `'open' | 'closed' | 'merged'` enum. Folding `merged` into the state
  * preserves the function's existing contract + tests.
+ *
+ * `updatedAt` (added in scout 0.9.0) flows through unchanged so consumers
+ * can hand the result to `isLinkedPRStalled` without re-fetching.
  */
 export function adaptScoutLinkedPR(scoutLinkedPR) {
     if (!scoutLinkedPR)
         return null;
-    return {
+    const adapted = {
         author: { login: scoutLinkedPR.author },
         state: scoutLinkedPR.merged ? 'merged' : scoutLinkedPR.state,
     };
+    if (scoutLinkedPR.updatedAt !== undefined) {
+        adapted.updatedAt = scoutLinkedPR.updatedAt;
+    }
+    return adapted;
+}
+/**
+ * Build the autopilot-shaped `linkedPR` slice consumed by `SearchOutput`,
+ * `VetOutput`, and `FeaturesOutput` from scout's raw `LinkedPR`
+ * (#97 / scout 0.9.0). Returns `undefined` when scout reported no linked
+ * PR. Computes `isStalled` from the adapted (autopilot-shape) PR so the
+ * rule stays consistent with `classifyLinkedPR` and downstream consumers.
+ */
+export function buildCandidateLinkedPR(scoutLinkedPR) {
+    if (!scoutLinkedPR)
+        return undefined;
+    const adapted = adaptScoutLinkedPR(scoutLinkedPR);
+    if (!adapted)
+        return undefined;
+    const linkedPR = {
+        number: scoutLinkedPR.number,
+        state: adapted.state,
+        url: scoutLinkedPR.url,
+        isStalled: isLinkedPRStalled(adapted),
+    };
+    if (scoutLinkedPR.updatedAt !== undefined) {
+        linkedPR.updatedAt = scoutLinkedPR.updatedAt;
+    }
+    return linkedPR;
 }
 /**
  * Build a ScoutState from the current AgentState.
@@ -50,6 +81,15 @@ export function buildScoutState() {
             persistence: config.persistence,
             slmTriageModel: config.slmTriageModel,
             slmTriageHost: config.slmTriageHost,
+            // Scout 0.9.0 made these required on `ScoutPreferences` (their schema
+            // ZodDefaults still apply at parse time, but the inferred TS type now
+            // demands the fields). We pass scout's documented defaults here so
+            // autopilot doesn't have to introduce a new pair of user-visible
+            // settings just to satisfy the type. The features CLI command
+            // (#runFeatures) accepts per-call `--anchor-threshold` and
+            // `--split-ratio` flags for overrides.
+            featuresAnchorThreshold: 3,
+            featuresSplitRatio: 0.6,
         },
         repoScores: state.repoScores,
         starredRepos: config.starredRepos,

package/dist/commands/search.js

@@ -2,7 +2,7 @@
  * Search command
  * Searches for new issues to work on via @oss-scout/core
  */
-import { createAutopilotScout } from './scout-bridge.js';
+import { buildCandidateLinkedPR, createAutopilotScout } from './scout-bridge.js';
 import { getStateManager } from '../core/index.js';
 import { gradeFromCandidate } from '../core/issue-grading.js';
 import { warn } from '../core/logger.js';
@@ -71,6 +71,7 @@ export async function runSearch(options) {
                         : undefined;
                 },
             });
+            const linkedPR = buildCandidateLinkedPR(c.vettingResult?.linkedPR);
             return {
                 issue: {
                     repo: c.issue.repo,
@@ -95,6 +96,7 @@ export async function runSearch(options) {
                         lastMergedAt: repoScoreRecord.lastMergedAt,
                     }
                     : undefined,
+                ...(linkedPR ? { linkedPR } : {}),
             };
         }),
         excludedRepos: result.excludedRepos,

package/dist/commands/startup.js

@@ -14,6 +14,7 @@ import { errorMessage } from '../core/errors.js';
 import { warn } from '../core/logger.js';
 import { executeDailyCheck } from './daily.js';
 import { launchDashboardServer } from './dashboard-lifecycle.js';
+import { recordBrowserOpened } from './dashboard-process.js';
 import { parseIssueList } from './parse-list.js';
 /**
  * Parse issueListPath from a config file's YAML frontmatter.
@@ -181,6 +182,48 @@ export function openInBrowser(url) {
  * Hits POST /api/refresh so the SPA picks up fresh data on its next poll.
  * Non-fatal: errors are logged but don't propagate (#830).
  */
+const DEFAULT_REOPEN_THROTTLE_MS = 30 * 60 * 1000; // 30 minutes
+/**
+ * Resolve the browser-reopen throttle window from `OSS_DASHBOARD_REOPEN_THROTTLE_MS`,
+ * falling back to {@link DEFAULT_REOPEN_THROTTLE_MS}. A value of `0` disables the
+ * throttle entirely, restoring the pre-#1339 behavior of always re-opening.
+ */
+function getReopenThrottleMs() {
+    const raw = process.env.OSS_DASHBOARD_REOPEN_THROTTLE_MS;
+    if (!raw)
+        return DEFAULT_REOPEN_THROTTLE_MS;
+    const n = Number(raw);
+    return Number.isFinite(n) && n >= 0 ? n : DEFAULT_REOPEN_THROTTLE_MS;
+}
+/**
+ * Decide whether `openInBrowser` should run. Throttles re-opens against an
+ * already-running server's `lastBrowserOpenedAt` timestamp so back-to-back
+ * `/oss` runs don't pile up duplicate tabs (#1339), while still re-surfacing
+ * the dashboard for users who closed the tab and came back later (#1100).
+ *
+ * Fresh launches (`alreadyRunning === false`) always open; the new server has
+ * no recorded open yet by definition.
+ *
+ * Set `OSS_NO_BROWSER=1` to skip opening unconditionally (e.g., headless / CI).
+ */
+function shouldOpenBrowser(spaResult, throttleMs) {
+    if (process.env.OSS_NO_BROWSER === '1')
+        return false;
+    if (!spaResult.alreadyRunning)
+        return true;
+    if (throttleMs === 0)
+        return true;
+    const last = spaResult.lastBrowserOpenedAt;
+    if (!last)
+        return true;
+    const lastMs = Date.parse(last);
+    if (!Number.isFinite(lastMs))
+        return true;
+    const elapsed = Date.now() - lastMs;
+    if (elapsed < 0)
+        return true; // clock skew or future timestamp; treat as stale
+    return elapsed >= throttleMs;
+}
 async function triggerDashboardRefresh(port) {
     try {
         const res = await fetch(`http://127.0.0.1:${port}/api/refresh`, {
@@ -271,12 +314,15 @@ export async function runStartup() {
             else {
                 dashboardStatus = 'opened';
             }
-            // `open`/`xdg-open`/`start` focus an existing tab matching the URL
-            // instead of duplicating it, so this is safe whether the server was
-            // just started or was already running. Closes #830 properly — a user
-            // can close the dashboard tab while the daemon keeps running, leaving
-            // subsequent /oss runs with no visible dashboard if we didn't re-open.
-            openInBrowser(spaResult.url);
+            // Throttle re-opens against the running server's last-opened timestamp
+            // so back-to-back /oss runs don't pile up duplicate tabs (#1339), while
+            // still re-surfacing the dashboard for users who closed the tab and
+            // came back later (#1100). `OSS_NO_BROWSER=1` skips entirely;
+            // `OSS_DASHBOARD_REOPEN_THROTTLE_MS=0` restores always-open behavior.
+            if (shouldOpenBrowser(spaResult, getReopenThrottleMs())) {
+                openInBrowser(spaResult.url);
+                recordBrowserOpened(spaResult.port);
+            }
         }
         else {
             dashboardError = 'Dashboard SPA assets not found. Build with: cd packages/dashboard && pnpm run build';

package/dist/commands/vet-list.js

@@ -3,7 +3,7 @@
  * Re-vets all available issues in a curated issue list file via @oss-scout/core.
  */
 import * as fs from 'node:fs';
-import { adaptScoutLinkedPR, createAutopilotScout } from './scout-bridge.js';
+import { adaptScoutLinkedPR, buildCandidateLinkedPR, createAutopilotScout } from './scout-bridge.js';
 import { runParseList, pruneIssueList } from './parse-list.js';
 import { detectIssueList } from './startup.js';
 import { computeSuccessGrade, gradeFromCandidate } from '../core/issue-grading.js';
@@ -17,7 +17,7 @@ const KNOWN_SKIP_REASONS = new Set([
     'anti_llm_policy',
     'other',
 ]);
-function mapSkipReasonToStatus(reason) {
+function mapSkipReasonToStatus(reason, vetResult) {
     switch (reason) {
         case 'issue_closed': {
             return 'closed';
@@ -26,6 +26,12 @@ function mapSkipReasonToStatus(reason) {
             return 'claimed';
         }
         case 'has_linked_pr': {
+            // Open linked PRs that have been idle for 30+ days are revive
+            // opportunities (#97 / scout 0.9.0) — surface them with a distinct
+            // status rather than auto-dropping as `has_pr`.
+            if (vetResult.linkedPR?.state === 'open' && vetResult.linkedPR.isStalled) {
+                return 'has_stalled_pr';
+            }
             return 'has_pr';
         }
         case 'score_too_low':
@@ -57,7 +63,7 @@ export function extractSkipReason(candidate) {
  */
 export function classifyListStatus(vetResult, skipReason) {
     if (skipReason) {
-        const fromEnum = mapSkipReasonToStatus(skipReason);
+        const fromEnum = mapSkipReasonToStatus(skipReason, vetResult);
         if (fromEnum)
             return fromEnum;
         // skipReason was set but maps to 'other' / low-score / policy — let the
@@ -69,8 +75,15 @@ export function classifyListStatus(vetResult, skipReason) {
             return 'closed';
         if (skipReasons.some((r) => r.includes('claimed') || r.includes('assigned')))
             return 'claimed';
-        if (skipReasons.some((r) => r.includes('existing pr') || r.includes('linked pr') || r.includes('pull request')))
+        if (skipReasons.some((r) => r.includes('existing pr') || r.includes('linked pr') || r.includes('pull request'))) {
+            // Same revive-opportunity branch as the enum path above — when scout
+            // hasn't yet emitted skipReason but we can see a stalled open PR on
+            // the candidate, prefer the dedicated status (#97 / scout 0.9.0).
+            if (vetResult.linkedPR?.state === 'open' && vetResult.linkedPR.isStalled) {
+                return 'has_stalled_pr';
+            }
             return 'has_pr';
+        }
     }
     if (vetResult.recommendation === 'approve' || vetResult.recommendation === 'needs_review') {
         return 'still_available';
@@ -102,7 +115,7 @@ export async function runVetList(options = {}) {
     if (parsed.available.length === 0) {
         return {
             results: [],
-            summary: { total: 0, stillAvailable: 0, claimed: 0, closed: 0, hasPR: 0, errors: 0 },
+            summary: { total: 0, stillAvailable: 0, claimed: 0, closed: 0, hasPR: 0, hasStalledPR: 0, errors: 0 },
         };
     }
     // 2. Vet each available issue in parallel with concurrency limit
@@ -126,6 +139,7 @@ export async function runVetList(options = {}) {
                     linkedPR: adaptScoutLinkedPR(candidate.vettingResult.linkedPR),
                     userLogin,
                 });
+                const linkedPR = buildCandidateLinkedPR(candidate.vettingResult.linkedPR);
                 const vetResult = {
                     issue: {
                         repo: candidate.issue.repo,
@@ -141,6 +155,7 @@ export async function runVetList(options = {}) {
                     vettingResult: candidate.vettingResult,
                     antiLLMPolicy: candidate.antiLLMPolicy,
                     linkedPRClassification,
+                    ...(linkedPR ? { linkedPR } : {}),
                     slmTriage: candidate.slmTriage ?? null,
                     grade,
                 };
@@ -175,6 +190,7 @@ export async function runVetList(options = {}) {
         claimed: results.filter((r) => r.listStatus === 'claimed').length,
         closed: results.filter((r) => r.listStatus === 'closed').length,
         hasPR: results.filter((r) => r.listStatus === 'has_pr').length,
+        hasStalledPR: results.filter((r) => r.listStatus === 'has_stalled_pr').length,
         errors: results.filter((r) => r.listStatus === 'error').length,
     };
     // 4. Prune the file if requested — remove completed/skipped/low-score items

package/dist/commands/vet.js

@@ -2,7 +2,7 @@
  * Vet command
  * Vets a specific issue before working on it via @oss-scout/core
  */
-import { createAutopilotScout, adaptScoutLinkedPR } from './scout-bridge.js';
+import { adaptScoutLinkedPR, buildCandidateLinkedPR, createAutopilotScout } from './scout-bridge.js';
 import { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
 import { gradeFromCandidate } from '../core/issue-grading.js';
 import { getStateManager, classifyLinkedPR } from '../core/index.js';
@@ -29,6 +29,7 @@ export async function runVet(options) {
         linkedPR: adaptScoutLinkedPR(candidate.vettingResult.linkedPR),
         userLogin,
     });
+    const linkedPR = buildCandidateLinkedPR(candidate.vettingResult.linkedPR);
     return {
         issue: {
             repo: candidate.issue.repo,
@@ -44,6 +45,7 @@ export async function runVet(options) {
         vettingResult: candidate.vettingResult,
         antiLLMPolicy: candidate.antiLLMPolicy,
         linkedPRClassification,
+        ...(linkedPR ? { linkedPR } : {}),
         slmTriage: candidate.slmTriage ?? null,
         grade,
     };

package/dist/core/index.d.ts

@@ -21,7 +21,7 @@ export { HttpCache, getHttpCache, cachedRequest, type CacheEntry } from './http-
 export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, buildStarFilter, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
 export { computeContributionStats, type ContributionStats, type ComputeStatsInput } from './stats.js';
 export { fetchPRTemplate, type PRTemplateResult } from './pr-template.js';
-export { classifyLinkedPR, type LinkedPR, type LinkedPRClassification, type LinkedPRState, } from './linked-pr-classification.js';
+export { classifyLinkedPR, isLinkedPRStalled, STALLED_PR_THRESHOLD_DAYS, type LinkedPR, type LinkedPRClassification, type LinkedPRState, } from './linked-pr-classification.js';
 export { scanForAntiLLMPolicy, type AntiLLMCategory, type AntiLLMMatch, type AntiLLMScanResult, } from './anti-llm-policy.js';
 export { detectFormatters, diagnoseCIFormatterFailure, getPreferredFormatter, type DetectedFormatter, type FormatterDetectionResult, type CIFormatterDiagnosis, type FormatterName, } from './formatter-detection.js';
 export { CONFIG_KEY_REGISTRY, type ConfigKeyDef, type SettableVia, isKnownKey, getKeyDef, getSetupKeys, getConfigKeys, suggestKey, formatUnknownKeyError, } from './config-registry.js';

package/dist/core/index.js

@@ -22,7 +22,7 @@ export { HttpCache, getHttpCache, cachedRequest } from './http-cache.js';
 export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, buildStarFilter, formatActionHint, formatBriefSummary, formatSummary, printDigest, } from './daily-logic.js';
 export { computeContributionStats } from './stats.js';
 export { fetchPRTemplate } from './pr-template.js';
-export { classifyLinkedPR, } from './linked-pr-classification.js';
+export { classifyLinkedPR, isLinkedPRStalled, STALLED_PR_THRESHOLD_DAYS, } from './linked-pr-classification.js';
 export { scanForAntiLLMPolicy, } from './anti-llm-policy.js';
 export { detectFormatters, diagnoseCIFormatterFailure, getPreferredFormatter, } from './formatter-detection.js';
 export { CONFIG_KEY_REGISTRY, isKnownKey, getKeyDef, getSetupKeys, getConfigKeys, suggestKey, formatUnknownKeyError, } from './config-registry.js';