@oss-autopilot/core 3.5.0 → 3.7.0

package/dist/commands/daily.d.ts

@@ -7,6 +7,7 @@
  * orchestration layer that wires up the phases and handles I/O.
  */
 import { type DailyDigest, type CommentedIssue, type PRCheckFailure, type RepoGroup } from '../core/index.js';
+import { type StrategyResult } from '../core/strategy.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';
 import { buildStarFilter } from '../core/daily-logic.js';
@@ -28,6 +29,13 @@ export interface DailyCheckResult {
     failures: PRCheckFailure[];
     /** Non-fatal warnings from ancillary pipeline phases — see #1042. */
     warnings: DailyWarning[];
+    /**
+     * Periodic strategy snapshot (#1270). Set when the cadence trigger
+     * fires AND the user has crossed `STRATEGY_MIN_PRS`. The action-menu
+     * renderer in `commands/oss.md` reads this; absent or null on runs
+     * where the gate stays silent.
+     */
+    strategySummary?: StrategyResult | null;
 }
 /**
  * Convert a full DailyCheckResult to the compact DailyOutput for JSON serialization (#287).

package/dist/commands/daily.js

@@ -8,6 +8,7 @@
  */
 import { getStateManager, PRMonitor, IssueConversationMonitor, requireGitHubToken, CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, formatBriefSummary, formatSummary, } from '../core/index.js';
 import { errorMessage, isRateLimitOrAuthError } from '../core/errors.js';
+import { computeStrategy, shouldComputeStrategy } from '../core/strategy.js';
 import { warn } from '../core/logger.js';
 import { emptyPRCountsResult } from '../core/github-stats.js';
 import { createAutopilotScout } from './scout-bridge.js';
@@ -421,6 +422,24 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
     const briefSummary = formatBriefSummary(digest, actionableIssues.length, issueResponses.length);
     const actionMenu = computeActionMenu(actionableIssues, capacity, filteredCommentedIssues);
     const repoGroups = groupPRsByRepo(activePRs);
+    // Periodic strategy snapshot (#1270 Step 2). Cadence-gated to fire every
+    // 30 days OR after 5+ PRs merge since the last snapshot, whichever comes
+    // first. Below STRATEGY_MIN_PRS the gate stays silent. Compute failures
+    // are non-fatal — the daily run continues and the snapshot is omitted.
+    let strategySummary;
+    try {
+        const state = stateManager.getState();
+        const nowIso = new Date().toISOString();
+        if (shouldComputeStrategy(state, nowIso)) {
+            strategySummary = computeStrategy(state);
+            if (strategySummary) {
+                stateManager.setLastStrategyAt(nowIso);
+            }
+        }
+    }
+    catch (error) {
+        recordWarning(warnings, 'analytics', 'compute strategy snapshot', error);
+    }
     return {
         digest,
         capacity,
@@ -432,6 +451,7 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
         repoGroups,
         failures,
         warnings,
+        strategySummary,
     };
 }
 // ---------------------------------------------------------------------------
@@ -457,6 +477,7 @@ export function toDailyOutput(result) {
         repoGroups: compactRepoGroups(result.repoGroups),
         failures: result.failures,
         warnings: result.warnings,
+        strategySummary: result.strategySummary,
     };
 }
 /**

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. */
@@ -75,6 +77,8 @@ export { runStateUnlink } from './state-cmd.js';
 export { runParseList, pruneIssueList } from './parse-list.js';
 /** Move an issue between Pursue / Maybe / Skip sections of a curated list (#1107). */
 export { runListMoveTier, moveIssueToTier, type Tier, type ListMoveTierOptions, type ListMoveTierOutput, } from './list-move-tier.js';
+/** Mark an issue line in a curated list as done with strikethrough + Done sub-bullet (#1299). */
+export { runMarkIssueListItemDone, markIssueAsDone, type MarkDoneOptions, type MarkDoneOutput, } from './list-mark-done.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** System-health diagnostic — verifies tokens, bundle, state, scout, rate limit. */
@@ -85,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. */
@@ -82,6 +84,8 @@ export { runStateUnlink } from './state-cmd.js';
 export { runParseList, pruneIssueList } from './parse-list.js';
 /** Move an issue between Pursue / Maybe / Skip sections of a curated list (#1107). */
 export { runListMoveTier, moveIssueToTier, } from './list-move-tier.js';
+/** Mark an issue line in a curated list as done with strikethrough + Done sub-bullet (#1299). */
+export { runMarkIssueListItemDone, markIssueAsDone, } from './list-mark-done.js';
 /** Check if new files are properly referenced/integrated. */
 export { runCheckIntegration } from './check-integration.js';
 /** System-health diagnostic — verifies tokens, bundle, state, scout, rate limit. */

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.
@@ -115,11 +116,33 @@ export function detectIssueList() {
         // Matches the sibling warn at line 64 for `issueListPath` read failures.
         warn('startup', `Could not read skippedIssuesPath from state: ${errorMessage(err)}`);
     }
-    // Probe default path: same directory as issue list, named skipped-issues.md
+    // Probe default path: same directory as issue list, named skipped-issues.md.
+    // When found, also persist to state.config so downstream commands
+    // (`skip-add`, `scout search`'s skip-list filter) read the same path
+    // instead of silently no-opping with "No skipped-issues path configured"
+    // (#1330). Without persistence, the auto-detect printed the path on
+    // every startup but nothing else honored it — search would re-surface
+    // already-skipped candidates round after round.
     if (!skippedIssuesPath && issueListPath) {
         const defaultSkipPath = path.join(path.dirname(issueListPath), 'skipped-issues.md');
         if (fs.existsSync(defaultSkipPath)) {
             skippedIssuesPath = defaultSkipPath;
+            try {
+                const stateManager = getStateManager();
+                // Only write when config actually doesn't have one — re-running
+                // startup shouldn't trigger an autoSave on every run if the
+                // value is already there.
+                const current = stateManager.getState().config.skippedIssuesPath;
+                if (!current) {
+                    stateManager.updateConfig({ skippedIssuesPath: defaultSkipPath });
+                }
+            }
+            catch (err) {
+                // Persistence is best-effort — startup still surfaces the path
+                // in its return value so the current run benefits, but the next
+                // run won't. Log so the failure is debuggable.
+                warn('startup', `Could not persist auto-detected skippedIssuesPath: ${errorMessage(err)}`);
+            }
         }
     }
     return { path: issueListPath, source, availableCount, completedCount, skippedIssuesPath };
@@ -159,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`, {
@@ -249,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';