@oss-scout/core 0.11.0 → 1.1.0

package/dist/formatters/human.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Human-readable (non-JSON) output formatters for the oss-scout CLI.
+ *
+ * Each renderer is a pure function that returns the exact multi-line string the
+ * CLI used to emit via a sequence of `console.log` calls. The caller does a
+ * single `console.log(renderX(...))`, which appends the one trailing newline
+ * that the final `console.log` in the old inline block produced.
+ *
+ * To stay byte-identical: every old `console.log(line)` becomes one entry in a
+ * lines array, a bare `console.log()` (blank line) becomes an empty entry, and
+ * the array is joined with "\n". The caller's own `console.log` supplies the
+ * last newline. STDERR output (the search rate-limit warning) is deliberately
+ * NOT folded in here — it stays a `console.error` in the caller.
+ */
+import type { SearchOutput } from "../commands/search.js";
+import type { FeaturesOutput } from "../commands/features.js";
+import type { SavedCandidate } from "../core/schemas.js";
+import type { VetListResult } from "../core/types.js";
+import type { VetOutput } from "../commands/vet.js";
+/** Emoji for a vetting recommendation, shared by the search and vet renderers. */
+export declare function recommendationIcon(recommendation: "approve" | "skip" | "needs_review"): string;
+/**
+ * Render the human-readable `search` output: the "Found N issue candidates"
+ * block with per-candidate icon, personalization and stalled tags, and the
+ * optional repoScore line. The trailing rate-limit warning is NOT included
+ * here; it goes to stderr in the caller.
+ */
+export declare function renderSearch(results: SearchOutput): string;
+/**
+ * Render the human-readable `features` output: the optional message, the
+ * "Feature opportunities" header, the anchor repos line, and the Quick wins /
+ * Bigger bets sections. Returns "" when there is nothing to print beyond an
+ * absent message (caller guards against logging a blank line).
+ */
+export declare function renderFeatures(result: FeaturesOutput, options: {
+    broad?: boolean;
+}): string;
+/** The empty-state message printed by `results` when nothing is saved. */
+export declare const RESULTS_EMPTY_MESSAGE = "\nNo saved results. Run `oss-scout search` to find issues.\n";
+/**
+ * Render the human-readable `results` table: the "Saved results" header and a
+ * Score / Repo / Issue / Recommendation / Title row per saved candidate.
+ * Callers handle the empty state (RESULTS_EMPTY_MESSAGE) separately.
+ */
+export declare function renderResults(results: SavedCandidate[]): string;
+/** The empty-state message printed by `vet-list` when there is nothing to vet. */
+export declare const VET_LIST_EMPTY_MESSAGE = "\nNo saved results to vet. Run `oss-scout search` first.\n";
+/**
+ * Render the human-readable `vet-list` output: the "Vet-list results (N)"
+ * block with a per-row status icon, the "Changes since last check"
+ * transitions block, the summary line, and the optional pruned-count line.
+ * Callers handle the empty state (VET_LIST_EMPTY_MESSAGE) separately.
+ */
+export declare function renderVetList(result: VetListResult): string;
+/**
+ * Render the human-readable single-issue `vet` output: the recommendation
+ * header, the reasons to approve / skip, and the project-health block. The
+ * checkFailed branch (#158) is preserved exactly.
+ */
+export declare function renderVet(result: VetOutput): string;

package/dist/formatters/human.js

@@ -0,0 +1,199 @@
+/**
+ * Human-readable (non-JSON) output formatters for the oss-scout CLI.
+ *
+ * Each renderer is a pure function that returns the exact multi-line string the
+ * CLI used to emit via a sequence of `console.log` calls. The caller does a
+ * single `console.log(renderX(...))`, which appends the one trailing newline
+ * that the final `console.log` in the old inline block produced.
+ *
+ * To stay byte-identical: every old `console.log(line)` becomes one entry in a
+ * lines array, a bare `console.log()` (blank line) becomes an empty entry, and
+ * the array is joined with "\n". The caller's own `console.log` supplies the
+ * last newline. STDERR output (the search rate-limit warning) is deliberately
+ * NOT folded in here — it stays a `console.error` in the caller.
+ */
+/** Emoji for a vetting recommendation, shared by the search and vet renderers. */
+export function recommendationIcon(recommendation) {
+    if (recommendation === "approve")
+        return "✅";
+    if (recommendation === "skip")
+        return "❌";
+    return "⚠️";
+}
+/**
+ * Render the human-readable `search` output: the "Found N issue candidates"
+ * block with per-candidate icon, personalization and stalled tags, and the
+ * optional repoScore line. The trailing rate-limit warning is NOT included
+ * here; it goes to stderr in the caller.
+ */
+export function renderSearch(results) {
+    const lines = [];
+    lines.push(`\nFound ${results.candidates.length} issue candidates:\n`);
+    for (const c of results.candidates) {
+        const icon = recommendationIcon(c.recommendation);
+        const stalledTag = c.linkedPR?.isStalled
+            ? " (stalled PR, revive opportunity)"
+            : "";
+        // Personalization tag (#1244). A candidate is either boosted (matched a
+        // preference) or a diversity slot (matched none and filled a reserved
+        // slot); never both.
+        let personalizationTag = "";
+        if (c.boostReasons && c.boostReasons.length > 0) {
+            // Net score can be negative when avoidRepos applied (#168).
+            const verb = (c.boostScore ?? 0) >= 0 ? "boosted" : "deprioritized";
+            personalizationTag = ` [${verb}: ${c.boostReasons.join("; ")}]`;
+        }
+        else if (c.diversitySlot) {
+            personalizationTag = " [diversity slot]";
+        }
+        lines.push(`  ${icon} ${c.issue.repo}#${c.issue.number} [${c.viabilityScore}/100]${personalizationTag}${stalledTag}`);
+        lines.push(`     ${c.issue.title}`);
+        lines.push(`     ${c.issue.url}`);
+        if (c.repoScore) {
+            lines.push(`     Repo: ${c.repoScore.score}/10, ${c.repoScore.mergedPRCount} merged PRs`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Render the human-readable `features` output: the optional message, the
+ * "Feature opportunities" header, the anchor repos line, and the Quick wins /
+ * Bigger bets sections. Returns "" when there is nothing to print beyond an
+ * absent message (caller guards against logging a blank line).
+ */
+export function renderFeatures(result, options) {
+    const lines = [];
+    const total = result.quickWins.length + result.biggerBets.length;
+    if (result.message) {
+        lines.push(`\n${result.message}\n`);
+    }
+    if (total === 0)
+        return lines.join("\n");
+    const headerScope = options.broad
+        ? "across the ecosystem"
+        : "in your anchor repos";
+    lines.push(`\n🎯 Feature opportunities ${headerScope} (${result.quickWins.length} quick wins + ${result.biggerBets.length} bigger bets)\n`);
+    if (!options.broad) {
+        lines.push(`Anchor repos: ${result.anchorRepos.join(", ")}\n`);
+    }
+    if (result.quickWins.length) {
+        lines.push("── Quick wins ─────────────────────────────────────────");
+        for (const c of result.quickWins) {
+            const stalledTag = c.linkedPR?.isStalled
+                ? " (stalled PR, revive opportunity)"
+                : "";
+            lines.push(`  ${c.issue.repo}#${c.issue.number} [${c.viabilityScore}/100] ${c.issue.title}${stalledTag}`);
+            lines.push(`     ${c.issue.url}`);
+        }
+        lines.push("");
+    }
+    if (result.biggerBets.length) {
+        lines.push("── Bigger bets ────────────────────────────────────────");
+        for (const c of result.biggerBets) {
+            const stalledTag = c.linkedPR?.isStalled
+                ? " (stalled PR, revive opportunity)"
+                : "";
+            lines.push(`  ${c.issue.repo}#${c.issue.number} [${c.viabilityScore}/100] ${c.issue.title}${stalledTag}`);
+            lines.push(`     ${c.issue.url}`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/** The empty-state message printed by `results` when nothing is saved. */
+export const RESULTS_EMPTY_MESSAGE = "\nNo saved results. Run `oss-scout search` to find issues.\n";
+/**
+ * Render the human-readable `results` table: the "Saved results" header and a
+ * Score / Repo / Issue / Recommendation / Title row per saved candidate.
+ * Callers handle the empty state (RESULTS_EMPTY_MESSAGE) separately.
+ */
+export function renderResults(results) {
+    const lines = [];
+    lines.push(`\nSaved results (${results.length}):\n`);
+    lines.push("  Score  Repo                              Issue   Recommendation  Title");
+    lines.push("  ─────  ────────────────────────────────  ──────  ──────────────  ─────");
+    for (const r of results) {
+        const score = String(r.viabilityScore).padStart(3);
+        const repo = r.repo.padEnd(32).slice(0, 32);
+        const issue = `#${r.number}`.padEnd(6);
+        const rec = r.recommendation.padEnd(14);
+        const title = r.title.length > 50 ? r.title.slice(0, 47) + "..." : r.title;
+        lines.push(`  ${score}    ${repo}  ${issue}  ${rec}  ${title}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/** The empty-state message printed by `vet-list` when there is nothing to vet. */
+export const VET_LIST_EMPTY_MESSAGE = "\nNo saved results to vet. Run `oss-scout search` first.\n";
+/** Icon for a vet-list entry's availability status. */
+function vetListStatusIcon(status) {
+    return status === "still_available"
+        ? "✅"
+        : status === "claimed"
+            ? "🔒"
+            : status === "has_pr"
+                ? "🔀"
+                : status === "closed"
+                    ? "🚫"
+                    : "❌";
+}
+/**
+ * Render the human-readable `vet-list` output: the "Vet-list results (N)"
+ * block with a per-row status icon, the "Changes since last check"
+ * transitions block, the summary line, and the optional pruned-count line.
+ * Callers handle the empty state (VET_LIST_EMPTY_MESSAGE) separately.
+ */
+export function renderVetList(result) {
+    const lines = [];
+    lines.push(`\nVet-list results (${result.summary.total}):\n`);
+    for (const r of result.results) {
+        const icon = vetListStatusIcon(r.status);
+        const score = r.ok ? ` [${r.viabilityScore}/100]` : "";
+        lines.push(`  ${icon} ${r.repo}#${r.number} — ${r.status}${score}`);
+        lines.push(`     ${r.title}`);
+    }
+    if (result.transitions.length > 0) {
+        lines.push(`\n🔔 Changes since last check (${result.transitions.length}):`);
+        for (const t of result.transitions) {
+            lines.push(`  ${t.repo}#${t.number}: ${t.from} → ${t.to}`);
+        }
+    }
+    lines.push(`\nSummary: ${result.summary.stillAvailable} available, ${result.summary.claimed} claimed, ${result.summary.hasPR} has PR, ${result.summary.closed} closed, ${result.summary.errors} errors`);
+    if (result.prunedCount != null) {
+        lines.push(`Pruned ${result.prunedCount} unavailable issues from saved results.`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Render the human-readable single-issue `vet` output: the recommendation
+ * header, the reasons to approve / skip, and the project-health block. The
+ * checkFailed branch (#158) is preserved exactly.
+ */
+export function renderVet(result) {
+    const lines = [];
+    const icon = recommendationIcon(result.recommendation);
+    lines.push(`\n${icon} ${result.issue.repo}#${result.issue.number}: ${result.recommendation.toUpperCase()}`);
+    lines.push(`   ${result.issue.title}`);
+    lines.push(`   ${result.issue.url}\n`);
+    if (result.reasonsToApprove.length > 0) {
+        lines.push("Reasons to approve:");
+        for (const r of result.reasonsToApprove)
+            lines.push(`  + ${r}`);
+    }
+    if (result.reasonsToSkip.length > 0) {
+        lines.push("Reasons to skip:");
+        for (const r of result.reasonsToSkip)
+            lines.push(`  - ${r}`);
+    }
+    if (result.projectHealth.checkFailed) {
+        lines.push(`\nProject health: unknown (check failed: ${result.projectHealth.failureReason})`);
+    }
+    else {
+        lines.push(`\nProject health: ${result.projectHealth.isActive ? "Active" : "Inactive"}`);
+        lines.push(`  Last commit: ${result.projectHealth.daysSinceLastCommit} days ago`);
+        lines.push(`  CI status: ${result.projectHealth.ciStatus}`);
+    }
+    return lines.join("\n");
+}

package/dist/formatters/markdown.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Markdown output formatter (#170) — renders saved results as a table for
+ * digests, notes export, and scheduled GitHub-issue summaries.
+ */
+import type { SavedCandidate } from "../core/schemas.js";
+/**
+ * Render saved results as a GitHub-flavored markdown table, sorted by
+ * viability score descending. Returns a friendly message when empty.
+ */
+export declare function formatResultsMarkdown(results: SavedCandidate[]): string;

package/dist/formatters/markdown.js

@@ -0,0 +1,31 @@
+/**
+ * Markdown output formatter (#170) — renders saved results as a table for
+ * digests, notes export, and scheduled GitHub-issue summaries.
+ */
+/** Escape pipe and newline so a title can't break the markdown table. */
+function cell(value) {
+    return value.replace(/\r?\n/g, " ").replace(/\|/g, "\\|").trim();
+}
+/**
+ * Render saved results as a GitHub-flavored markdown table, sorted by
+ * viability score descending. Returns a friendly message when empty.
+ */
+export function formatResultsMarkdown(results) {
+    if (results.length === 0) {
+        return "_No saved results._";
+    }
+    const sorted = [...results].sort((a, b) => b.viabilityScore - a.viabilityScore);
+    const header = "| Score | Repo | Issue | Recommendation | Title |";
+    const divider = "| ----- | ---- | ----- | -------------- | ----- |";
+    const rows = sorted.map((r) => {
+        const issueLink = `[#${r.number}](${r.issueUrl})`;
+        return `| ${r.viabilityScore} | ${cell(r.repo)} | ${issueLink} | ${cell(r.recommendation)} | ${cell(r.title)} |`;
+    });
+    return [
+        `## oss-scout results (${results.length})`,
+        "",
+        header,
+        divider,
+        ...rows,
+    ].join("\n");
+}

package/dist/index.d.ts

@@ -15,13 +15,17 @@
  * @packageDocumentation
  */
 export { createScout, OssScout } from "./scout.js";
-export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectHealth, SearchPriority, CheckResult, AntiLLMPolicyResult, AntiLLMPolicySourceFile, VetListOptions, VetListResult, VetListEntry, VetListSummary, } from "./core/types.js";
+export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectHealth, ProjectHealthData, ProjectHealthFailure, SearchPriority, CheckResult, AntiLLMPolicyResult, AntiLLMPolicySourceFile, VetListOptions, VetListResult, VetListEntry, VetListEntryBase, VetListSummary, SyncResult, } from "./core/types.js";
 export type { ScoutState, ScoutPreferences, RepoScore, RepoSignals, IssueVettingResult, LinkedPR, ContributionGuidelines, TrackedIssue, IssueScope, ProjectCategory, StoredMergedPR, StoredClosedPR, StoredOpenPR, SearchStrategy, SkippedIssue, Horizon, } from "./core/schemas.js";
 export { ScoutStateSchema, ScoutPreferencesSchema, RepoScoreSchema, IssueScopeSchema, ProjectCategorySchema, SearchStrategySchema, SkippedIssueSchema, HorizonSchema, } from "./core/schemas.js";
+export { applyPreferenceField, FIELD_CONFIGS, PREFERENCE_KEYS, SORTED_PREFERENCE_KEYS, assertFieldConfigsCover, updateArray, type FieldConfig, } from "./core/preference-fields.js";
 export { requireGitHubToken, getGitHubToken } from "./core/utils.js";
 export { IssueDiscovery } from "./core/issue-discovery.js";
-export { IssueVetter, type ScoutStateReader, type FeatureSignals, } from "./core/issue-vetting.js";
+export { IssueVetter, type ScoutStateReader, type ScoutStateWriter, type SLMConfig, type FeatureSignals, } from "./core/issue-vetting.js";
 export { scanForAntiLLMPolicy, ANTI_LLM_KEYWORDS, } from "./core/anti-llm-policy.js";
+export { bootstrapScout, type BootstrapResult } from "./core/bootstrap.js";
+export { setLogLevel, getLogLevel, enableDebug, type LogLevel, } from "./core/logger.js";
 export { discoverFeatures, resolveAnchorRepos, classifyHorizon, splitByHorizon, ANCHOR_THRESHOLD, FEATURE_LABELS, NO_ANCHORS_MESSAGE, NO_RESULTS_MESSAGE, type FeatureCandidate, type FeatureSearchResult, type DiscoverFeaturesOptions, } from "./core/feature-discovery.js";
 export { isLinkedPRStalled, STALLED_PR_THRESHOLD_DAYS, } from "./core/linked-pr.js";
 export { fetchRoadmapIssueRefs, parseRoadmapIssueRefs, } from "./core/roadmap.js";
+export { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl, } from "./commands/validation.js";

package/dist/index.js

@@ -18,15 +18,23 @@
 export { createScout, OssScout } from "./scout.js";
 // Schemas (for consumers who need runtime validation)
 export { ScoutStateSchema, ScoutPreferencesSchema, RepoScoreSchema, IssueScopeSchema, ProjectCategorySchema, SearchStrategySchema, SkippedIssueSchema, HorizonSchema, } from "./core/schemas.js";
+// Preference-field metadata + parsing (shared by the CLI and the MCP server)
+export { applyPreferenceField, FIELD_CONFIGS, PREFERENCE_KEYS, SORTED_PREFERENCE_KEYS, assertFieldConfigsCover, updateArray, } from "./core/preference-fields.js";
 // Utilities
 export { requireGitHubToken, getGitHubToken } from "./core/utils.js";
 // Internal classes (for advanced use)
 export { IssueDiscovery } from "./core/issue-discovery.js";
 export { IssueVetter, } from "./core/issue-vetting.js";
 export { scanForAntiLLMPolicy, ANTI_LLM_KEYWORDS, } from "./core/anti-llm-policy.js";
+// Bootstrap (seed state from GitHub) — usable by library/MCP hosts (#156)
+export { bootstrapScout } from "./core/bootstrap.js";
+// Log-level control for library hosts (#156)
+export { setLogLevel, getLogLevel, enableDebug, } from "./core/logger.js";
 // Feature discovery API
 export { discoverFeatures, resolveAnchorRepos, classifyHorizon, splitByHorizon, ANCHOR_THRESHOLD, FEATURE_LABELS, NO_ANCHORS_MESSAGE, NO_RESULTS_MESSAGE, } from "./core/feature-discovery.js";
 // Linked-PR helpers (#97)
 export { isLinkedPRStalled, STALLED_PR_THRESHOLD_DAYS, } from "./core/linked-pr.js";
 // Roadmap scraping (#95)
 export { fetchRoadmapIssueRefs, parseRoadmapIssueRefs, } from "./core/roadmap.js";
+// Issue-URL validation (shared by the CLI and the MCP server)
+export { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl, } from "./commands/validation.js";

package/dist/scout.d.ts

@@ -4,11 +4,19 @@
  * Provides personalized issue discovery, vetting, and scoring.
  * Implements ScoutStateReader to bridge state with the search engine.
  */
-import type { ScoutStateReader } from "./core/issue-vetting.js";
+import type { ScoutStateReader, ScoutStateWriter, SLMConfig } from "./core/issue-vetting.js";
 import { type FeatureSearchResult } from "./core/feature-discovery.js";
 import type { ScoutState, ScoutPreferences, RepoScore, SavedCandidate, SkippedIssue, Horizon } from "./core/schemas.js";
-import type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectCategory, VetListOptions, VetListResult } from "./core/types.js";
+import type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectCategory, SyncResult, VetListOptions, VetListResult } from "./core/types.js";
 import { GistStateStore } from "./core/gist-state-store.js";
+import type { GistOctokitLike } from "./core/gist-state-store.js";
+import type { Octokit } from "@octokit/rest";
+/**
+ * Wrap a real Octokit instance as GistOctokitLike without unsafe double casts.
+ * Exported (not via the package index) so the response-narrowing logic — the
+ * "no id" guards and the files/list mapping — is unit-testable (#162).
+ */
+export declare function toGistOctokit(octokit: Octokit): GistOctokitLike;
 /**
  * Create an OssScout instance.
  *
@@ -37,17 +45,42 @@ export declare function createScout(config: ScoutConfig): Promise<OssScout>;
  * Implements ScoutStateReader so the search engine can read state
  * without knowing about the persistence layer.
  */
-export declare class OssScout implements ScoutStateReader {
+export declare class OssScout implements ScoutStateReader, ScoutStateWriter {
     private githubToken;
     private gistStore;
     private state;
     private dirty;
-    constructor(githubToken: string, initialState: ScoutState, gistStore?: GistStateStore | null);
+    /** When true, checkpoint() also writes ~/.oss-scout/state.json. */
+    private persistLocal;
+    constructor(githubToken: string, initialState: ScoutState, gistStore?: GistStateStore | null, opts?: {
+        persistLocal?: boolean;
+    });
+    /**
+     * Drop stale disk-cache entries. Called at the top of every cache-burning
+     * entry point (search, features, vetList); without it ~/.oss-scout/cache
+     * grows without bound. evictStale never throws (fs errors degrade to warn).
+     */
+    private evictStaleCacheEntries;
     /**
      * Multi-strategy issue search. Returns scored, sorted candidates.
      * Automatically culls expired skip entries and filters skipped issues.
      */
     search(options?: SearchOptions): Promise<SearchResult>;
+    /**
+     * Populate the `hasActiveMaintainers` repo-score signal from a freshly
+     * computed projectHealth (#167). It was initialized false and never set, so
+     * calculateScore's +1 active-maintainers weight was inert; `isActive`
+     * (recent commit activity) is a real, already-computed proxy.
+     *
+     * `isResponsive` and `avgResponseDays` are deliberately NOT set here, and
+     * `isResponsive` no longer carries a score weight at all (#167): real
+     * responsiveness needs an actual response-time measurement (extra API calls)
+     * that is out of scope, and `hasActiveMaintainers` already covers the
+     * activity proxy. `hasHostileComments` stays a host-settable capability (it
+     * needs comment sentiment, out of scope). A failed health check is skipped so
+     * its neutral-default fields don't pollute the score.
+     */
+    private updateRepoSignalsFromHealth;
     /**
      * Vet a single issue URL for claimability.
      */
@@ -83,15 +116,21 @@ export declare class OssScout implements ScoutStateReader {
     getReposWithOpenPRs(): string[];
     getStarredRepos(): string[];
     getProjectCategories(): ProjectCategory[];
+    /** Configured GitHub username (used to classify own vs competing PRs, #166). */
+    getGitHubUsername(): string;
     getRepoScore(repo: string): number | null;
     /**
-     * Optional SLM pre-triage config read from preferences (oss-autopilot#1122).
-     * Empty `model` disables the call; the vetter treats it as a no-op.
+     * Number of the user's PRs closed without merge in this repo (#125).
+     * Prefers the tracked repo score; falls back to counting closedPRs so the
+     * scoring penalty works even before a score record exists.
      */
-    getSLMTriageConfig(): {
-        model: string;
-        host: string;
-    };
+    getClosedWithoutMergeCount(repo: string): number;
+    /**
+     * SLM pre-triage config read from preferences (oss-autopilot#1122). Returns
+     * `null` when no `slmTriageModel` is configured — the vetter skips the SLM
+     * call entirely (#158).
+     */
+    getSLMTriageConfig(): SLMConfig | null;
     /** Get current preferences (read-only). */
     getPreferences(): Readonly<ScoutPreferences>;
     /** Get repo score record for a specific repository. */
@@ -110,6 +149,17 @@ export declare class OssScout implements ScoutStateReader {
      * Open PRs signal active engagement even when nothing is merged yet.
      */
     recordOpenPR(pr: OpenPRRecord): void;
+    /**
+     * Reconcile tracked open PRs against their current GitHub state (#164).
+     *
+     * `state.openPRs` was append-only — nothing transitioned an open PR to
+     * merged/closed, so getReposWithOpenPRs() over-reported forever once a PR
+     * merged. This checks each open PR, records merges/closures (which updates
+     * the repo score), prunes resolved entries, and checkpoints. Cheaper than a
+     * full bootstrap, so a host can call it on daily startup. Transient errors
+     * leave the entry in place; auth/rate-limit failures propagate.
+     */
+    syncOpenPRs(): Promise<SyncResult>;
     /**
      * Update repo score with observed signals.
      */
@@ -138,6 +188,12 @@ export declare class OssScout implements ScoutStateReader {
      * Clear all saved results.
      */
     clearResults(): void;
+    /**
+     * Record deletion tombstones (#117) so a later gist merge does not
+     * resurrect these URLs from another machine's copy. A re-add with a newer
+     * timestamp overrides the tombstone in mergeStates.
+     */
+    private addTombstones;
     /**
      * Skip an issue — excludes it from future searches. Auto-culled after 90 days.
      */
@@ -178,9 +234,16 @@ export declare class OssScout implements ScoutStateReader {
     getState(): Readonly<ScoutState>;
     private updateRepoScoreFromPRs;
     /**
-     * Calculate repo score (1-10) from observed data.
+     * Calculate repo score from observed data.
      * base 5, +1 per merged PR (max +3), -1 per closed-without-merge (max -3),
-     * +1 responsive, +1 active maintainers, -2 hostile comments, clamped 1-10
+     * +1 active maintainers, -2 hostile comments, clamped to [1, 10].
+     *
+     * `isResponsive` is intentionally NOT scored (#167): nothing in oss-scout
+     * ever computes it, so awarding +1 for it was dead weight that the
+     * now-computed `hasActiveMaintainers` signal already covers as the activity
+     * proxy. The field is retained on RepoSignals for backward compatibility but
+     * no longer affects the score. With the current signals the reachable range
+     * is [1, 9]; the upper clamp stays as defensive hygiene.
      */
     private calculateScore;
 }