@oss-autopilot/core 1.15.0 → 1.15.2

package/dist/commands/daily.d.ts

@@ -33,6 +33,15 @@ export interface DailyCheckResult {
     repoGroups: RepoGroup[];
     failures: PRCheckFailure[];
 }
+/**
+ * Convert a full DailyCheckResult to the compact DailyOutput for JSON serialization (#287).
+ * Deduplicates PR objects: category arrays become PR URL references,
+ * full objects live only in digest.openPRs. Reduces JSON payload size ~60-70%.
+ *
+ * Exported for the `daily --json` contract test (#986), which pins this
+ * shape transformation without spinning up the full fetch pipeline.
+ */
+export declare function toDailyOutput(result: DailyCheckResult): DailyOutput;
 /**
  * Core daily check logic, extracted for reuse by the startup command.
  * Fetches all open PRs, updates state, and returns structured output.

package/dist/commands/daily.js

@@ -370,8 +370,11 @@ function generateDigestOutput(digest, activePRs, shelvedPRs, commentedIssues, fa
  * Convert a full DailyCheckResult to the compact DailyOutput for JSON serialization (#287).
  * Deduplicates PR objects: category arrays become PR URL references,
  * full objects live only in digest.openPRs. Reduces JSON payload size ~60-70%.
+ *
+ * Exported for the `daily --json` contract test (#986), which pins this
+ * shape transformation without spinning up the full fetch pipeline.
  */
-function toDailyOutput(result) {
+export function toDailyOutput(result) {
     return {
         digest: deduplicateDigest(result.digest),
         capacity: result.capacity,

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

@@ -5,6 +5,8 @@
  *
  * Uses Node's built-in http module — no Express/Fastify.
  */
+import { type DashboardJsonData } from './dashboard-data.js';
+import { type DailyDigest, type AgentState, type CommentedIssue, type MergedPR, type ClosedPR } from '../core/types.js';
 export { getDashboardPidPath, writeDashboardServerInfo, readDashboardServerInfo, removeDashboardServerInfo, isDashboardServerRunning, findRunningDashboardServer, type DashboardServerInfo, } from './dashboard-process.js';
 export interface DashboardServerOptions {
     port: number;
@@ -12,4 +14,12 @@ export interface DashboardServerOptions {
     token: string | null;
     open: boolean;
 }
+/**
+ * Build the JSON payload that the SPA expects from GET /api/data.
+ *
+ * Exported for unit testing of response-shape concerns that the full
+ * handler harness can't reach (it bakes a stale cachedDigest at server
+ * start-up, so tests that need a specific digest should call this directly).
+ */
+export declare function buildDashboardJson(digest: DailyDigest, state: Readonly<AgentState>, commentedIssues: CommentedIssue[], allMergedPRs?: MergedPR[], allClosedPRs?: ClosedPR[]): DashboardJsonData;
 export declare function startDashboardServer(options: DashboardServerOptions): Promise<void>;

package/dist/commands/dashboard-server.js

@@ -68,8 +68,12 @@ function getIssueListMtimeMs() {
 }
 /**
  * Build the JSON payload that the SPA expects from GET /api/data.
+ *
+ * Exported for unit testing of response-shape concerns that the full
+ * handler harness can't reach (it bakes a stale cachedDigest at server
+ * start-up, so tests that need a specific digest should call this directly).
  */
-function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs) {
+export function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClosedPRs) {
     const prsByRepo = computePRsByRepo(digest, state);
     const topRepos = computeTopRepos(prsByRepo);
     const { monthlyMerged, monthlyOpened, monthlyClosed } = getMonthlyData(state);
@@ -104,7 +108,11 @@ function buildDashboardJson(digest, state, commentedIssues, allMergedPRs, allClo
         monthlyOpened,
         monthlyClosed,
         activePRs: applyStatusOverrides(digest.openPRs || [], state),
-        shelvedPRUrls: state.config.shelvedPRUrls || [],
+        // Source of truth is digest.shelvedPRs (union of explicitly-shelved URLs
+        // 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 || [],

package/dist/commands/scout-bridge.js

@@ -4,6 +4,7 @@
  */
 import { createScout } from '@oss-scout/core';
 import { getStateManager, requireGitHubToken } from '../core/index.js';
+import { loadSkippedIssues } from './skip-file-parser.js';
 /**
  * Build a ScoutState from the current AgentState.
  * Maps oss-autopilot's config and state fields to oss-scout's state format.
@@ -52,7 +53,7 @@ export function buildScoutState() {
             openedAt: pr.createdAt,
         })),
         savedResults: [],
-        skippedIssues: [],
+        skippedIssues: loadSkippedIssues(config.skippedIssuesPath),
         lastRunAt: state.lastRunAt,
     };
 }

package/dist/commands/skip-add.d.ts

@@ -0,0 +1,25 @@
+export interface SkipAddOptions {
+    issueUrl: string;
+    /** Override the configured `skippedIssuesPath`. */
+    skipFilePath?: string;
+    /** Injected for deterministic tests. Defaults to `new Date()`. */
+    now?: Date;
+}
+export interface SkipAddOutput {
+    added: boolean;
+    alreadyPresent: boolean;
+    url: string;
+    path: string;
+    /** Populated only when an entry was appended. */
+    date?: string;
+}
+/**
+ * Append an issue URL to the skipped-issues file.
+ *
+ * Creates the file with the standard header if it doesn't exist. If the URL
+ * is already present (per the skip-file-parser's view of the file), this is
+ * a no-op and returns `alreadyPresent: true`.
+ *
+ * @throws when no path can be resolved or the URL isn't a GitHub issue/PR URL.
+ */
+export declare function runSkipAdd(options: SkipAddOptions): SkipAddOutput;

package/dist/commands/skip-add.js

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+import { loadSkippedIssues } from './skip-file-parser.js';
+import { getStateManager } from '../core/index.js';
+// Keep in sync with GITHUB_URL_RE in skip-file-parser.ts.
+const GITHUB_URL_RE = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/(?:issues|pull)\/(\d+)(?:[/?#].*)?$/;
+const FILE_HEADER = '# Skipped Issues — auto-culled after 90 days\n# Format: YYYY-MM-DD URL\n\n';
+function formatUtcDate(d) {
+    return d.toISOString().slice(0, 10);
+}
+/**
+ * Append an issue URL to the skipped-issues file.
+ *
+ * Creates the file with the standard header if it doesn't exist. If the URL
+ * is already present (per the skip-file-parser's view of the file), this is
+ * a no-op and returns `alreadyPresent: true`.
+ *
+ * @throws when no path can be resolved or the URL isn't a GitHub issue/PR URL.
+ */
+export function runSkipAdd(options) {
+    const skipFilePath = options.skipFilePath ?? getStateManager().getState().config.skippedIssuesPath;
+    if (!skipFilePath) {
+        throw new Error('No skipped-issues path configured. Set one via `oss-autopilot config --set skippedIssuesPath=<path>` or pass --path.');
+    }
+    if (!GITHUB_URL_RE.test(options.issueUrl)) {
+        throw new Error(`Invalid GitHub issue or PR URL: ${options.issueUrl}`);
+    }
+    const existing = loadSkippedIssues(skipFilePath);
+    if (existing.some((entry) => entry.url === options.issueUrl)) {
+        return {
+            added: false,
+            alreadyPresent: true,
+            url: options.issueUrl,
+            path: skipFilePath,
+        };
+    }
+    if (!fs.existsSync(skipFilePath)) {
+        fs.writeFileSync(skipFilePath, FILE_HEADER);
+    }
+    const date = formatUtcDate(options.now ?? new Date());
+    fs.appendFileSync(skipFilePath, `${date} ${options.issueUrl}\n`);
+    return {
+        added: true,
+        alreadyPresent: false,
+        url: options.issueUrl,
+        path: skipFilePath,
+        date,
+    };
+}

package/dist/commands/skip-file-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Parser for the skipped-issues markdown file (#989).
+ *
+ * The file format is one entry per line:
+ *   2026-04-15 https://github.com/owner/repo/issues/123
+ * Lines starting with `#` and blank lines are ignored.
+ *
+ * Produces SkippedIssue entries that plug directly into oss-scout's ScoutState
+ * so the search engine filters already-skipped URLs out of results.
+ */
+import type { SkippedIssue } from '@oss-scout/core';
+/**
+ * Parse the raw text of a skipped-issues file into SkippedIssue entries.
+ * Pure function — no I/O. Malformed lines are warned and skipped; the rest
+ * pass through unchanged.
+ */
+export declare function parseSkippedIssuesContent(content: string): SkippedIssue[];
+/**
+ * Read the skipped-issues file from disk and parse it.
+ * Returns `[]` when:
+ *   - `path` is undefined or empty,
+ *   - the file does not exist,
+ *   - the file cannot be read (a warning is logged).
+ */
+export declare function loadSkippedIssues(path: string | undefined): SkippedIssue[];

package/dist/commands/skip-file-parser.js

@@ -0,0 +1,92 @@
+/**
+ * Parser for the skipped-issues markdown file (#989).
+ *
+ * The file format is one entry per line:
+ *   2026-04-15 https://github.com/owner/repo/issues/123
+ * Lines starting with `#` and blank lines are ignored.
+ *
+ * Produces SkippedIssue entries that plug directly into oss-scout's ScoutState
+ * so the search engine filters already-skipped URLs out of results.
+ */
+import * as fs from 'fs';
+import { warn } from '../core/logger.js';
+import { errorMessage } from '../core/errors.js';
+const DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+const GITHUB_URL_RE = /^https:\/\/github\.com\/([^/]+\/[^/]+)\/(?:issues|pull)\/(\d+)(?:[/?#].*)?$/;
+/**
+ * Parse the raw text of a skipped-issues file into SkippedIssue entries.
+ * Pure function — no I/O. Malformed lines are warned and skipped; the rest
+ * pass through unchanged.
+ */
+export function parseSkippedIssuesContent(content) {
+    const results = [];
+    const lines = content.split(/\r?\n/);
+    for (let i = 0; i < lines.length; i++) {
+        const lineNumber = i + 1;
+        const line = lines[i].trim();
+        if (line === '' || line.startsWith('#'))
+            continue;
+        // Split on first whitespace run: "YYYY-MM-DD <url>"
+        const match = line.match(/^(\S+)\s+(\S+)\s*$/);
+        if (!match) {
+            warn('skip-file-parser', `Line ${lineNumber}: malformed (expected "<date> <url>"): ${line}`);
+            continue;
+        }
+        const [, dateStr, url] = match;
+        if (!DATE_RE.test(dateStr)) {
+            warn('skip-file-parser', `Line ${lineNumber}: invalid date format (expected YYYY-MM-DD): ${line}`);
+            continue;
+        }
+        const dateMs = Date.parse(`${dateStr}T00:00:00.000Z`);
+        if (Number.isNaN(dateMs)) {
+            warn('skip-file-parser', `Line ${lineNumber}: unparseable date: ${line}`);
+            continue;
+        }
+        // Guard against JS Date normalization — Date.parse silently shifts
+        // invalid calendar dates (e.g. 2026-02-30 → 2026-03-02). Without this
+        // round-trip check the entry would be stored under the wrong date and
+        // scout's 90-day cull would run against a shifted value.
+        const roundTrip = new Date(dateMs).toISOString().slice(0, 10);
+        if (roundTrip !== dateStr) {
+            warn('skip-file-parser', `Line ${lineNumber}: invalid calendar date ${dateStr} (would be normalized to ${roundTrip}): ${line}`);
+            continue;
+        }
+        const urlMatch = url.match(GITHUB_URL_RE);
+        if (!urlMatch) {
+            warn('skip-file-parser', `Line ${lineNumber}: non-GitHub-issue URL: ${line}`);
+            continue;
+        }
+        const [, repo, numberStr] = urlMatch;
+        const number = Number.parseInt(numberStr, 10);
+        results.push({
+            url,
+            repo,
+            number,
+            title: '',
+            skippedAt: new Date(dateMs).toISOString(),
+        });
+    }
+    return results;
+}
+/**
+ * Read the skipped-issues file from disk and parse it.
+ * Returns `[]` when:
+ *   - `path` is undefined or empty,
+ *   - the file does not exist,
+ *   - the file cannot be read (a warning is logged).
+ */
+export function loadSkippedIssues(path) {
+    if (!path)
+        return [];
+    if (!fs.existsSync(path))
+        return [];
+    let content;
+    try {
+        content = fs.readFileSync(path, 'utf-8');
+    }
+    catch (err) {
+        warn('skip-file-parser', `Failed to read skipped-issues file at ${path}: ${errorMessage(err)}`);
+        return [];
+    }
+    return parseSkippedIssuesContent(content);
+}

package/dist/commands/vet-list.js

@@ -6,6 +6,9 @@ import * as fs from 'fs';
 import { 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';
+import { getStateManager } from '../core/index.js';
+const UNKNOWN_GRADE = computeSuccessGrade({ avgResponseDays: null, mergeRate: null, daysSinceLastCommit: null });
 /**
  * Determine the list status from vetting results.
  * Maps vetting recommendation + reasons to a list-level status.
@@ -62,6 +65,11 @@ export async function runVetList(options = {}) {
             const item = items[index++];
             try {
                 const candidate = await scout.vetIssue(item.url);
+                const grade = gradeFromCandidate({
+                    repo: candidate.issue.repo,
+                    projectHealth: candidate.projectHealth,
+                    getRepoScore: (repo) => getStateManager().getRepoScore(repo),
+                });
                 const vetResult = {
                     issue: {
                         repo: candidate.issue.repo,
@@ -75,6 +83,7 @@ export async function runVetList(options = {}) {
                     reasonsToSkip: candidate.reasonsToSkip,
                     projectHealth: candidate.projectHealth,
                     vettingResult: candidate.vettingResult,
+                    grade,
                 };
                 results.push({
                     ...vetResult,
@@ -90,6 +99,7 @@ export async function runVetList(options = {}) {
                     reasonsToSkip: [`Error: ${error instanceof Error ? error.message : String(error)}`],
                     projectHealth: {},
                     vettingResult: {},
+                    grade: UNKNOWN_GRADE,
                     listStatus: 'error',
                     errorMessage: error instanceof Error ? error.message : String(error),
                 });

package/dist/commands/vet.js

@@ -4,6 +4,8 @@
  */
 import { createAutopilotScout } from './scout-bridge.js';
 import { ISSUE_URL_PATTERN, validateGitHubUrl, validateUrl } from './validation.js';
+import { gradeFromCandidate } from '../core/issue-grading.js';
+import { getStateManager } from '../core/index.js';
 /**
  * Vet a specific GitHub issue for claimability and project health.
  *
@@ -17,6 +19,11 @@ export async function runVet(options) {
     validateGitHubUrl(options.issueUrl, ISSUE_URL_PATTERN, 'issue');
     const scout = await createAutopilotScout();
     const candidate = await scout.vetIssue(options.issueUrl);
+    const grade = gradeFromCandidate({
+        repo: candidate.issue.repo,
+        projectHealth: candidate.projectHealth,
+        getRepoScore: (repo) => getStateManager().getRepoScore(repo),
+    });
     return {
         issue: {
             repo: candidate.issue.repo,
@@ -30,5 +37,6 @@ export async function runVet(options) {
         reasonsToSkip: candidate.reasonsToSkip,
         projectHealth: candidate.projectHealth,
         vettingResult: candidate.vettingResult,
+        grade,
     };
 }

package/dist/core/anti-llm-policy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Anti-LLM policy scan (#108, #911, #979).
+ *
+ * Scan concatenated repo docs (CONTRIBUTING.md, CODE_OF_CONDUCT.md,
+ * README) for language that indicates the project does not accept
+ * AI/LLM-generated contributions. Previously described as a keyword
+ * table in prose in agents/issue-scout.md.
+ *
+ * The long-term home for this logic is `@oss-scout/core`, where the
+ * relevant files are already fetched during vetting. Keeping it here
+ * for now lets the agent invoke it directly and gives scout a
+ * reference implementation + test fixtures to adopt. See #979.
+ *
+ * Precision matters more than recall. False positives (flagging a
+ * project that actually welcomes AI help) silently shrink the user's
+ * contribution surface without recourse. We only match on phrases
+ * that combine a rejection keyword (no / reject / will be closed /
+ * don't accept) with an AI/LLM noun.
+ */
+export type AntiLLMCategory = 'explicit_ban' | 'tool_ban' | 'reject_framing';
+export interface AntiLLMMatch {
+    category: AntiLLMCategory;
+    /** The exact substring from the source text that triggered the match. */
+    phrase: string;
+    /** ~80 character window around the match, for surfacing to the user. */
+    excerpt: string;
+}
+export interface AntiLLMScanResult {
+    matched: boolean;
+    matches: AntiLLMMatch[];
+}
+export declare function scanForAntiLLMPolicy(text: string): AntiLLMScanResult;

package/dist/core/anti-llm-policy.js

@@ -0,0 +1,101 @@
+/**
+ * Anti-LLM policy scan (#108, #911, #979).
+ *
+ * Scan concatenated repo docs (CONTRIBUTING.md, CODE_OF_CONDUCT.md,
+ * README) for language that indicates the project does not accept
+ * AI/LLM-generated contributions. Previously described as a keyword
+ * table in prose in agents/issue-scout.md.
+ *
+ * The long-term home for this logic is `@oss-scout/core`, where the
+ * relevant files are already fetched during vetting. Keeping it here
+ * for now lets the agent invoke it directly and gives scout a
+ * reference implementation + test fixtures to adopt. See #979.
+ *
+ * Precision matters more than recall. False positives (flagging a
+ * project that actually welcomes AI help) silently shrink the user's
+ * contribution surface without recourse. We only match on phrases
+ * that combine a rejection keyword (no / reject / will be closed /
+ * don't accept) with an AI/LLM noun.
+ */
+const PATTERNS = [
+    // Explicit "no X" bans against AI/LLM nouns.
+    { category: 'explicit_ban', regex: /\bno\s+(ai|llm)[-\s](generated|authored|written|assisted|contributions?)/i },
+    { category: 'explicit_ban', regex: /\b(ban|banned|banning)\s+(ai|llm)\b/i },
+    // Named-tool bans. Optionally match a "-generated/-authored/-…"
+    // continuation (clear ban wording), and use a negative lookahead to
+    // reject unrelated hyphen-words like "no copilot-style autocomplete"
+    // (which describes a feature, not a contribution policy).
+    {
+        category: 'tool_ban',
+        regex: /\bno\s+(copilot|chatgpt|claude|cursor)(-(generated|authored|assisted|written))?(?![a-z-])/i,
+    },
+    { category: 'tool_ban', regex: /\bno\s+ai\s+coding\s+tools?\b/i },
+    // Rejection framing. To avoid false positives like "AI PRs are closed
+    // to new comments" (closed means something else) or "AI suggestions
+    // from your IDE" (not a contribution), we require both an AI/LLM
+    // qualifier AND a contribution noun AND a rejection verb phrase. The
+    // two patterns cover "AI-generated code will be closed" (with
+    // participle) and "AI contributions will be closed" (without).
+    {
+        category: 'reject_framing',
+        regex: /\b(ai|llm)[-\s](generated|assisted|authored|written)\s+(code|prs?|contributions?)\s+(will\s+be\s+(closed|rejected)|are\s+rejected)/i,
+    },
+    {
+        category: 'reject_framing',
+        regex: /\b(ai|llm)\s+(code|prs?|contributions?)\s+(will\s+be\s+(closed|rejected)|are\s+rejected)/i,
+    },
+    // "do/does not accept AI-{noun}" / "reject AI contributions" — both
+    // require a contribution noun to avoid matching "accept AI suggestions
+    // from your IDE" or similar incidental mentions.
+    {
+        category: 'reject_framing',
+        regex: /\b(do|does)(\s+not|n't)\s+accept\s+(ai|llm)[-\s](generated|assisted|authored|written|contributions?|code|prs?)\b/i,
+    },
+    { category: 'reject_framing', regex: /\breject\s+(ai|llm)\s+contributions?\b/i },
+];
+const EXCERPT_RADIUS = 40;
+function makeExcerpt(text, matchIndex, matchLength) {
+    const start = Math.max(0, matchIndex - EXCERPT_RADIUS);
+    const end = Math.min(text.length, matchIndex + matchLength + EXCERPT_RADIUS);
+    const prefix = start > 0 ? '…' : '';
+    const suffix = end < text.length ? '…' : '';
+    return `${prefix}${text.slice(start, end).replace(/\s+/g, ' ').trim()}${suffix}`;
+}
+/**
+ * Normalize exotic whitespace and hyphens so patterns written with plain
+ * ASCII still match real-world markdown. Covers non-breaking space,
+ * non-breaking hyphen, en dash, em dash, and figure dash — all of which
+ * show up in CONTRIBUTING files authored in rich-text editors.
+ */
+function normalizeText(text) {
+    return text
+        .normalize('NFKC')
+        .replace(/[\u00A0]/g, ' ')
+        .replace(/[\u2010\u2011\u2012\u2013\u2014\u2015]/g, '-');
+}
+export function scanForAntiLLMPolicy(text) {
+    if (typeof text !== 'string') {
+        throw new TypeError(`scanForAntiLLMPolicy: expected string, received ${typeof text}`);
+    }
+    if (text === '')
+        return { matched: false, matches: [] };
+    const normalized = normalizeText(text);
+    const seenLabels = new Set();
+    const matches = [];
+    for (const pattern of PATTERNS) {
+        const hit = normalized.match(pattern.regex);
+        if (!hit || hit.index === undefined)
+            continue;
+        const phrase = hit[0];
+        const key = `${pattern.category}:${phrase.toLowerCase()}`;
+        if (seenLabels.has(key))
+            continue;
+        seenLabels.add(key);
+        matches.push({
+            category: pattern.category,
+            phrase,
+            excerpt: makeExcerpt(normalized, hit.index, phrase.length),
+        });
+    }
+    return { matched: matches.length > 0, matches };
+}

package/dist/core/index.d.ts

@@ -15,5 +15,7 @@ export { HttpCache, getHttpCache, cachedRequest, type CacheEntry } from './http-
 export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, 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 { 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 * from './types.js';

package/dist/core/index.js

@@ -16,5 +16,7 @@ export { HttpCache, getHttpCache, cachedRequest } from './http-cache.js';
 export { CRITICAL_STATUSES, applyStatusOverrides, computeRepoSignals, groupPRsByRepo, assessCapacity, collectActionableIssues, computeActionMenu, toShelvedPRRef, 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 { scanForAntiLLMPolicy, } from './anti-llm-policy.js';
 export { detectFormatters, diagnoseCIFormatterFailure, getPreferredFormatter, } from './formatter-detection.js';
 export * from './types.js';

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

@@ -0,0 +1,75 @@
+/**
+ * Issue success-likelihood grade (#858).
+ *
+ * Predicts the probability that a contribution to a given repo will be
+ * accepted and merged, using signals already collected during vetting.
+ *
+ * The grade is letter-based (A/B/C/F — no D). Each signal is graded
+ * independently; the overall grade is the worst of the three, and is
+ * further degraded one step if any signal is unknown (missing data is
+ * treated as a risk, not ignored). This matches the policy previously
+ * described as prose in agents/issue-scout.md.
+ */
+export type GradeLetter = 'A' | 'B' | 'C' | 'F';
+export interface GradeSignals {
+    /** Average maintainer response time in days; null if unknown. */
+    avgResponseDays: number | null;
+    /** Fraction of recent PRs that merged (0–1); null if unknown. */
+    mergeRate: number | null;
+    /** Days since the most recent commit on the default branch; null if unknown. */
+    daysSinceLastCommit: number | null;
+}
+export interface GradeResult {
+    letter: GradeLetter;
+    /** Short human-readable explanation of what drove the grade. */
+    reason: string;
+}
+/**
+ * Build `GradeSignals` from a vet candidate's project health plus the
+ * optional autopilot-tracked repo score.
+ *
+ * Notes on each signal:
+ *
+ * - `avgResponseDays` — `@oss-scout/core`'s `projectHealth.avgIssueResponseDays`
+ *   is a hardcoded `0` placeholder (it doesn't yet make the additional API
+ *   calls needed to compute a real value). We therefore prefer
+ *   `repoScore.avgResponseDays`, which autopilot derives from its own PR
+ *   tracking, and fall back to `null` (unknown) if neither source has a
+ *   usable value.
+ * - `mergeRate` — derived from repoScore counts. Requires a non-empty PR
+ *   history; `0/0` is `null`, not `0`.
+ * - `daysSinceLastCommit` — taken from scout's `projectHealth`, but only
+ *   when scout's health check succeeded (`checkFailed` means scout filled
+ *   in sentinels and shouldn't be trusted).
+ */
+export declare function deriveGradeSignals(params: {
+    projectHealth: {
+        avgIssueResponseDays: number | null;
+        daysSinceLastCommit: number | null;
+        checkFailed?: boolean;
+    };
+    repoScore: {
+        mergedPRCount: number;
+        closedWithoutMergeCount: number;
+        avgResponseDays?: number | null;
+    } | null;
+}): GradeSignals;
+/**
+ * End-to-end helper for vet callers: reads the repo score, derives
+ * signals from a scout candidate, and returns the grade. Callers pass
+ * the `projectHealth` straight through from `scout.vetIssue()`.
+ */
+export declare function gradeFromCandidate(params: {
+    repo: string;
+    projectHealth: {
+        avgIssueResponseDays: number | null;
+        daysSinceLastCommit: number | null;
+        checkFailed?: boolean;
+    };
+    getRepoScore: (repo: string) => {
+        mergedPRCount: number;
+        closedWithoutMergeCount: number;
+        avgResponseDays: number | null;
+    } | undefined;
+}): GradeResult;
+export declare function computeSuccessGrade(signals: GradeSignals): GradeResult;