@oss-scout/mcp 0.8.0 → 0.10.0

package/dist/mcp-server.bundle.cjs

@@ -1,3 +1,4 @@
+#!/usr/bin/env node
 "use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
@@ -28888,13 +28889,13 @@ var zodToJsonSchema = (schema, options) => {
     }, true) ?? parseAnyDef(refs)
   }), {}) : void 0;
   const name = typeof options === "string" ? options : options?.nameStrategy === "title" ? void 0 : options?.name;
-  const main2 = parseDef(schema._def, name === void 0 ? refs : {
+  const main = parseDef(schema._def, name === void 0 ? refs : {
     ...refs,
     currentPath: [...refs.basePath, refs.definitionPath, name]
   }, false) ?? parseAnyDef(refs);
   const title = typeof options === "object" && options.name !== void 0 && options.nameStrategy === "title" ? options.name : void 0;
   if (title !== void 0) {
-    main2.title = title;
+    main.title = title;
   }
   if (refs.flags.hasReferencedOpenAiAnyType) {
     if (!definitions) {
@@ -28915,9 +28916,9 @@ var zodToJsonSchema = (schema, options) => {
     }
   }
   const combined = name === void 0 ? definitions ? {
-    ...main2,
+    ...main,
     [refs.definitionPath]: definitions
-  } : main2 : {
+  } : main : {
     $ref: [
       ...refs.$refStrategy === "relative" ? [] : refs.basePath,
       refs.definitionPath,
@@ -28925,7 +28926,7 @@ var zodToJsonSchema = (schema, options) => {
     ].join("/"),
     [refs.definitionPath]: {
       ...definitions,
-      [name]: main2
+      [name]: main
     }
   };
   if (refs.target === "jsonSchema7") {
@@ -30262,8 +30263,8 @@ var Server = class extends Protocol {
     this._loggingLevels = /* @__PURE__ */ new Map();
     this.LOG_LEVEL_SEVERITY = new Map(LoggingLevelSchema.options.map((level, index) => [level, index]));
     this.isMessageIgnored = (level, sessionId) => {
-      const currentLevel = this._loggingLevels.get(sessionId);
-      return currentLevel ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel) : false;
+      const currentLevel2 = this._loggingLevels.get(sessionId);
+      return currentLevel2 ? this.LOG_LEVEL_SEVERITY.get(level) < this.LOG_LEVEL_SEVERITY.get(currentLevel2) : false;
     };
     this._capabilities = options?.capabilities ?? {};
     this._instructions = options?.instructions;
@@ -35449,18 +35450,34 @@ throttling.VERSION = VERSION9;
 throttling.triggersNotification = triggersNotification;
 
 // ../core/dist/core/logger.js
-var debugEnabled = false;
+var LEVEL_RANK = {
+  silent: 0,
+  warn: 1,
+  info: 2,
+  debug: 3
+};
+var currentLevel = "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return LEVEL_RANK[currentLevel] >= LEVEL_RANK[level];
+}
 function debug(module2, message, ...args) {
-  if (!debugEnabled)
+  if (!shouldLog("debug"))
     return;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   console.error(`[${timestamp}] [DEBUG] [${module2}] ${message}`, ...args);
 }
 function info(module2, message, ...args) {
+  if (!shouldLog("info"))
+    return;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   console.error(`[${timestamp}] [INFO] [${module2}] ${message}`, ...args);
 }
 function warn(module2, message, ...args) {
+  if (!shouldLog("warn"))
+    return;
   const timestamp = (/* @__PURE__ */ new Date()).toISOString();
   console.error(`[${timestamp}] [WARN] [${module2}] ${message}`, ...args);
 }
@@ -35556,10 +35573,15 @@ function isRateLimitError(error48) {
     return true;
   if (status === 403) {
     const msg = errorMessage(error48).toLowerCase();
-    return msg.includes("rate limit");
+    return msg.includes("rate limit") || msg.includes("abuse detection");
   }
   return false;
 }
+function rethrowIfFatal(error48) {
+  if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+    throw error48;
+  }
+}
 
 // ../core/dist/core/utils.js
 function sleep(ms) {
@@ -35583,12 +35605,23 @@ function getCacheDir() {
   return dir;
 }
 function extractRepoFromUrl(url2) {
-  const apiMatch = url2.match(/api\.github\.com\/repos\/([^/]+\/[^/]+)/);
-  if (apiMatch)
-    return apiMatch[1];
-  const webMatch = url2.match(/github\.com\/([^/]+\/[^/]+)/);
-  if (webMatch)
-    return webMatch[1];
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch {
+    return null;
+  }
+  const host = parsed.hostname.toLowerCase().replace(/^www\./, "");
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  if (host === "api.github.com") {
+    if (segments[0] === "repos" && segments.length >= 3) {
+      return `${segments[1]}/${segments[2]}`;
+    }
+    return null;
+  }
+  if (host === "github.com" && segments.length >= 2) {
+    return `${segments[0]}/${segments[1]}`;
+  }
   return null;
 }
 var OWNER_PATTERN = /^[a-zA-Z0-9_-]+$/;
@@ -35597,25 +35630,29 @@ function isValidOwnerRepo(owner, repo) {
   return OWNER_PATTERN.test(owner) && REPO_PATTERN.test(repo);
 }
 function parseGitHubUrl(url2) {
-  if (!url2.startsWith("https://github.com/"))
+  const normalized = /^(?:www\.)?github\.com\//i.test(url2) ? `https://${url2}` : url2;
+  let parsed;
+  try {
+    parsed = new URL(normalized);
+  } catch {
     return null;
-  const prMatch = url2.match(/github\.com\/([^/]+)\/([^/]+)\/pull\/(\d+)/);
-  if (prMatch) {
-    const owner = prMatch[1];
-    const repo = prMatch[2];
-    if (!isValidOwnerRepo(owner, repo))
-      return null;
-    return { owner, repo, number: parseInt(prMatch[3], 10), type: "pull" };
-  }
-  const issueMatch = url2.match(/github\.com\/([^/]+)\/([^/]+)\/issues\/(\d+)/);
-  if (issueMatch) {
-    const owner = issueMatch[1];
-    const repo = issueMatch[2];
-    if (!isValidOwnerRepo(owner, repo))
-      return null;
-    return { owner, repo, number: parseInt(issueMatch[3], 10), type: "issues" };
   }
-  return null;
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:")
+    return null;
+  const host = parsed.hostname.toLowerCase().replace(/^www\./, "");
+  if (host !== "github.com")
+    return null;
+  const segments = parsed.pathname.split("/").filter(Boolean);
+  if (segments.length !== 4)
+    return null;
+  const [owner, repo, type, num] = segments;
+  if (type !== "pull" && type !== "issues")
+    return null;
+  if (!isValidOwnerRepo(owner, repo))
+    return null;
+  if (!/^\d+$/.test(num))
+    return null;
+  return { owner, repo, number: parseInt(num, 10), type };
 }
 function daysBetween(from, to = /* @__PURE__ */ new Date()) {
   return Math.max(0, Math.floor((to.getTime() - from.getTime()) / (1e3 * 60 * 60 * 24)));
@@ -35626,8 +35663,9 @@ function getGitHubToken() {
   if (tokenFetchAttempted)
     return null;
   tokenFetchAttempted = true;
-  if (process.env.GITHUB_TOKEN) {
-    cachedGitHubToken = process.env.GITHUB_TOKEN;
+  const envToken = process.env.GITHUB_TOKEN?.trim();
+  if (envToken) {
+    cachedGitHubToken = envToken;
     return cachedGitHubToken;
   }
   try {
@@ -35642,7 +35680,7 @@ function getGitHubToken() {
       return cachedGitHubToken;
     }
   } catch (err) {
-    debug(MODULE2, "gh auth token failed", err);
+    debug(MODULE2, `gh auth token failed: ${errorMessage(err)}`);
   }
   return null;
 }
@@ -35662,6 +35700,8 @@ var SearchBudgetTracker = class {
   resetAt = 0;
   /** Total calls recorded since init (for diagnostics). */
   totalCalls = 0;
+  /** Calls made since the last known quota reset (external accounting). */
+  callsSinceReset = 0;
   /**
    * Initialize with pre-flight rate limit data from GitHub.
    */
@@ -35670,6 +35710,7 @@ var SearchBudgetTracker = class {
     this.resetAt = new Date(resetAt).getTime();
     this.callTimestamps = [];
     this.totalCalls = 0;
+    this.callsSinceReset = 0;
     debug(MODULE3, `Initialized: ${remaining} remaining, resets at ${new Date(this.resetAt).toLocaleTimeString()}`);
   }
   /**
@@ -35678,8 +35719,28 @@ var SearchBudgetTracker = class {
   recordCall() {
     this.callTimestamps.push(Date.now());
     this.totalCalls++;
+    this.callsSinceReset++;
     this.pruneOldTimestamps();
   }
+  /**
+   * Replenish the external budget once GitHub's quota window has reset.
+   * Without this, the pre-flight remaining acted as a never-replenishing
+   * run-lifetime total, throttling long multi-phase runs to ~1 call/min
+   * even though GitHub fully resets every 60 seconds (#119).
+   */
+  refreshExternalBudget() {
+    if (this.resetAt <= 0)
+      return;
+    const now = Date.now();
+    if (now < this.resetAt)
+      return;
+    this.knownRemaining = SEARCH_RATE_LIMIT;
+    this.callsSinceReset = 0;
+    while (this.resetAt <= now) {
+      this.resetAt += SEARCH_WINDOW_MS;
+    }
+    debug(MODULE3, "Quota window reset; external search budget replenished");
+  }
   /**
    * Remove timestamps older than the sliding window.
    */
@@ -35701,8 +35762,9 @@ var SearchBudgetTracker = class {
    * and the pre-flight remaining quota from GitHub.
    */
   getEffectiveBudget() {
+    this.refreshExternalBudget();
     const localBudget = EFFECTIVE_BUDGET - this.callTimestamps.length;
-    const externalBudget = this.knownRemaining - this.totalCalls;
+    const externalBudget = this.knownRemaining - this.callsSinceReset;
     return Math.max(0, Math.min(localBudget, externalBudget));
   }
   /**
@@ -35725,6 +35787,12 @@ var SearchBudgetTracker = class {
       }
       const oldestInWindow = this.callTimestamps[0];
       if (!oldestInWindow) {
+        const untilReset = this.resetAt - Date.now();
+        if (this.resetAt > 0 && untilReset > 0) {
+          debug(MODULE3, `External quota exhausted, waiting ${untilReset}ms for reset`);
+          await sleep(untilReset + 100);
+          continue;
+        }
         return;
       }
       const waitUntil = oldestInWindow + SEARCH_WINDOW_MS;
@@ -35770,12 +35838,7 @@ var SCOPE_LABELS = {
 };
 
 // ../core/dist/core/schemas.js
-var IssueStatusSchema = external_exports3.enum([
-  "candidate",
-  "claimed",
-  "in_progress",
-  "pr_submitted"
-]);
+var IssueStatusSchema = external_exports3.enum(["candidate"]);
 var ProjectCategorySchema = external_exports3.enum([
   "nonprofit",
   "devtools",
@@ -35802,12 +35865,15 @@ var CONCRETE_STRATEGIES = [
   "broad",
   "maintained"
 ];
-var RepoSignalsSchema = external_exports3.object({
+var RepoSignalsSchema = external_exports3.looseObject({
   hasActiveMaintainers: external_exports3.boolean(),
+  // Retained for backward compatibility but no longer affects the repo score
+  // (#167): nothing computes it, and hasActiveMaintainers is the live activity
+  // proxy. Kept so old persisted state and the search JSON output still parse.
   isResponsive: external_exports3.boolean(),
   hasHostileComments: external_exports3.boolean()
 });
-var RepoScoreSchema = external_exports3.object({
+var RepoScoreSchema = external_exports3.looseObject({
   repo: external_exports3.string(),
   score: external_exports3.number(),
   mergedPRCount: external_exports3.number(),
@@ -35819,17 +35885,17 @@ var RepoScoreSchema = external_exports3.object({
   stargazersCount: external_exports3.number().optional(),
   language: external_exports3.string().nullable().optional()
 });
-var StoredMergedPRSchema = external_exports3.object({
+var StoredMergedPRSchema = external_exports3.looseObject({
   url: external_exports3.string(),
   title: external_exports3.string(),
   mergedAt: external_exports3.string()
 });
-var StoredClosedPRSchema = external_exports3.object({
+var StoredClosedPRSchema = external_exports3.looseObject({
   url: external_exports3.string(),
   title: external_exports3.string(),
   closedAt: external_exports3.string()
 });
-var StoredOpenPRSchema = external_exports3.object({
+var StoredOpenPRSchema = external_exports3.looseObject({
   url: external_exports3.string(),
   title: external_exports3.string(),
   openedAt: external_exports3.string()
@@ -35889,7 +35955,7 @@ var TrackedIssueSchema = external_exports3.object({
   vetted: external_exports3.boolean(),
   vettingResult: IssueVettingResultSchema.optional()
 });
-var SkippedIssueSchema = external_exports3.object({
+var SkippedIssueSchema = external_exports3.looseObject({
   url: external_exports3.string(),
   repo: external_exports3.string(),
   number: external_exports3.number(),
@@ -35897,7 +35963,7 @@ var SkippedIssueSchema = external_exports3.object({
   skippedAt: external_exports3.string()
 });
 var HorizonSchema = external_exports3.enum(["quick-win", "bigger-bet"]);
-var SavedCandidateSchema = external_exports3.object({
+var SavedCandidateSchema = external_exports3.looseObject({
   issueUrl: external_exports3.string(),
   repo: external_exports3.string(),
   number: external_exports3.number(),
@@ -35905,14 +35971,23 @@ var SavedCandidateSchema = external_exports3.object({
   labels: external_exports3.array(external_exports3.string()),
   recommendation: external_exports3.enum(["approve", "skip", "needs_review"]),
   viabilityScore: external_exports3.number(),
-  searchPriority: external_exports3.string(),
+  // Tightened from z.string() to the actual 3-value union (#158). `.catch`
+  // keeps old persisted state loadable: any unrecognized stored value (or a
+  // future-version value) decodes to "normal" instead of failing the parse.
+  searchPriority: external_exports3.enum(["merged_pr", "starred", "normal"]).catch("normal"),
   firstSeenAt: external_exports3.string(),
   lastSeenAt: external_exports3.string(),
   lastScore: external_exports3.number(),
-  horizon: HorizonSchema.optional()
+  horizon: HorizonSchema.optional(),
+  /**
+   * Availability status recorded by the previous `vet-list` run, so the next
+   * run can report transitions ("was available, now claimed") instead of
+   * re-diffing full snapshots (#165). "error" is never stored.
+   */
+  lastStatus: external_exports3.enum(["still_available", "claimed", "closed", "has_pr"]).optional()
 });
 var PersistenceModeSchema = external_exports3.enum(["local", "gist"]);
-var ScoutPreferencesSchema = external_exports3.object({
+var ScoutPreferencesSchema = external_exports3.looseObject({
   githubUsername: external_exports3.string().default(""),
   languages: external_exports3.array(external_exports3.string()).default(["any"]),
   labels: external_exports3.array(external_exports3.string()).default(["good first issue", "help wanted"]),
@@ -35928,8 +36003,28 @@ var ScoutPreferencesSchema = external_exports3.object({
   interPhaseDelayMs: external_exports3.number().min(0).max(12e4).default(3e4),
   persistence: PersistenceModeSchema.default("local"),
   defaultStrategy: external_exports3.array(SearchStrategySchema).optional(),
+  /**
+   * Persisted personalization defaults (#168). The `--prefer-languages`,
+   * `--prefer-repos`, and `--diversity-ratio` search flags override these when
+   * passed, so a stored preference removes the need to retype the boost every
+   * search. Empty / 0 disables the corresponding signal (same as the flags).
+   */
+  preferLanguages: external_exports3.array(external_exports3.string()).default([]),
+  preferRepos: external_exports3.array(external_exports3.string()).default([]),
+  diversityRatio: external_exports3.number().min(0).max(1).default(0),
+  // Soft penalty (milder than the hard excludeRepos filter): candidates in
+  // these `owner/repo` slugs are pushed down the ranking but not removed (#168).
+  avoidRepos: external_exports3.array(external_exports3.string()).default([]),
+  // Soft boost for candidates whose issue labels match one of these types,
+  // case-insensitive (e.g. "bug", "good first issue") (#168).
+  boostIssueTypes: external_exports3.array(external_exports3.string()).default([]),
   broadPhaseDelayMs: external_exports3.number().min(0).max(3e5).default(9e4),
-  skipBroadWhenSufficientResults: external_exports3.number().int().min(0).max(100).default(15),
+  /**
+   * Skip the expensive broad phase once this many candidates were found by
+   * the cheaper phases. Clamped at runtime to maxResults - 1 so it stays
+   * satisfiable; 0 disables skipping entirely.
+   */
+  skipBroadWhenSufficientResults: external_exports3.number().int().min(0).max(100).default(8),
   /**
    * Optional Ollama model id used for SLM pre-triage during vetting
    * (oss-autopilot#1122). Empty disables the feature. Recommended values:
@@ -35956,7 +36051,7 @@ var ScoutPreferencesSchema = external_exports3.object({
    */
   featuresSplitRatio: external_exports3.number().min(0).max(1).default(0.6)
 });
-var ScoutStateSchema = external_exports3.object({
+var ScoutStateSchema = external_exports3.looseObject({
   version: external_exports3.literal(1),
   preferences: ScoutPreferencesSchema.default(() => ScoutPreferencesSchema.parse({})),
   repoScores: external_exports3.record(external_exports3.string(), RepoScoreSchema).default({}),
@@ -35967,10 +36062,30 @@ var ScoutStateSchema = external_exports3.object({
   openPRs: external_exports3.array(StoredOpenPRSchema).default([]),
   savedResults: external_exports3.array(SavedCandidateSchema).default([]),
   skippedIssues: external_exports3.array(SkippedIssueSchema).default([]),
+  /**
+   * Deletion tombstones (#117). Without these, the gist union-merge would
+   * resurrect any saved result or skipped issue removed on one machine the
+   * next time it merged against another machine's copy that still had it.
+   * A tombstone suppresses an item across a merge until the item is
+   * re-added with a newer timestamp. Pruned after 90 days.
+   */
+  tombstones: external_exports3.array(external_exports3.looseObject({
+    url: external_exports3.string(),
+    removedAt: external_exports3.string()
+  })).default([]),
+  /**
+   * When preferences were last changed (#117). The gist merge previously
+   * always took the remote preferences, silently reverting a local edit;
+   * the side with the fresher timestamp now wins.
+   */
+  preferencesUpdatedAt: external_exports3.string().optional(),
   lastSearchAt: external_exports3.string().optional(),
   lastRunAt: external_exports3.string().default(() => (/* @__PURE__ */ new Date()).toISOString()),
   gistId: external_exports3.string().optional()
 });
+function parseScoutState(raw) {
+  return ScoutStateSchema.parse(raw);
+}
 
 // ../core/dist/core/issue-filtering.js
 var DOC_ONLY_LABELS = /* @__PURE__ */ new Set([
@@ -36268,6 +36383,10 @@ var fs2 = __toESM(require("fs"), 1);
 var path2 = __toESM(require("path"), 1);
 var crypto = __toESM(require("crypto"), 1);
 var MODULE4 = "http-cache";
+var CACHE_SCHEMA_VERSION = "v1";
+function versionedCacheKey(key) {
+  return `${CACHE_SCHEMA_VERSION}:${key}`;
+}
 var DEFAULT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
 var HttpCache = class {
   cacheDir;
@@ -36290,13 +36409,21 @@ var HttpCache = class {
    * (e.g., caching aggregated results from paginated API calls).
    */
   getIfFresh(key, maxAgeMs) {
+    return this.getEntryIfFresh(key, maxAgeMs)?.body ?? null;
+  }
+  /**
+   * Like {@link getIfFresh}, but returns the whole entry so callers can
+   * distinguish "no fresh entry" (null) from a legitimately cached falsy
+   * body (`0`, `""`, `false`, `null`).
+   */
+  getEntryIfFresh(key, maxAgeMs) {
     const entry = this.get(key);
     if (!entry)
       return null;
     const age = Date.now() - new Date(entry.cachedAt).getTime();
     if (!Number.isFinite(age) || age < 0 || age > maxAgeMs)
       return null;
-    return entry.body;
+    return entry;
   }
   /**
    * Look up a cached response. Returns `null` if no cache entry exists.
@@ -36447,12 +36574,21 @@ function getHttpCache() {
   }
   return _httpCache;
 }
-async function cachedRequest(cache, url2, fetcher) {
-  const existing = cache.getInflight(url2);
+async function withInflightDedup(cache, key, fn) {
+  const existing = cache.getInflight(key);
   if (existing) {
-    debug(MODULE4, `Dedup hit for ${url2}`);
+    debug(MODULE4, `Dedup hit for ${key}`);
     return await existing;
   }
+  const promise2 = fn();
+  const cleanup = cache.setInflight(key, promise2);
+  try {
+    return await promise2;
+  } finally {
+    cleanup();
+  }
+}
+async function cachedRequest(cache, url2, fetcher) {
   const doFetch = async () => {
     const extraHeaders = {};
     const cached2 = cache.get(url2);
@@ -36473,28 +36609,34 @@ async function cachedRequest(cache, url2, fetcher) {
           debug(MODULE4, `304 cache hit for ${url2}`);
           return freshCached.body;
         }
+        debug(MODULE4, `304 but cache entry vanished for ${url2}, refetching`);
+        const response = await fetcher({});
+        const etag = response.headers?.["etag"];
+        if (etag) {
+          cache.set(url2, etag, response.data);
+        }
+        return response.data;
       }
       throw err;
     }
   };
-  const promise2 = doFetch();
-  const cleanup = cache.setInflight(url2, promise2);
-  try {
-    const result = await promise2;
-    return result;
-  } finally {
-    cleanup();
-  }
+  return withInflightDedup(cache, url2, doFetch);
 }
 async function cachedTimeBased(cache, key, maxAgeMs, fetcher) {
-  const cached2 = cache.getIfFresh(key, maxAgeMs);
+  const cached2 = cache.getEntryIfFresh(key, maxAgeMs);
   if (cached2) {
     debug(MODULE4, `Time-based cache hit for ${key}`);
-    return cached2;
+    return cached2.body;
   }
-  const result = await fetcher();
-  cache.set(key, "", result);
-  return result;
+  return withInflightDedup(cache, key, async () => {
+    const fresh = cache.getEntryIfFresh(key, maxAgeMs);
+    if (fresh) {
+      return fresh.body;
+    }
+    const result = await fetcher();
+    cache.set(key, "", result);
+    return result;
+  });
 }
 function isNotModifiedError(err) {
   return getHttpStatusCode(err) === 304;
@@ -36531,23 +36673,36 @@ function buildLinkedPRFromTimelineEvent(e, context) {
   };
 }
 var MODULE5 = "issue-eligibility";
-var CLAIM_PHRASES = [
-  "i'm working on this",
-  "i am working on this",
-  "i'll take this",
-  "i will take this",
-  "working on it",
-  "i'd like to work on",
-  "i would like to work on",
-  "can i work on",
-  "may i work on",
-  "assigned to me",
-  "i'm on it",
-  "i'll submit a pr",
-  "i will submit a pr",
-  "working on a fix",
-  "working on a pr"
+var ISSUE_OBJECT = String.raw`(?:this\b|it\b|that\b|the\b|#\d+|issue\b)`;
+var FIRST_PERSON_CLAIM_PATTERNS = [
+  new RegExp(String.raw`\bi\s*(?:'ll|will) take ${ISSUE_OBJECT}`),
+  new RegExp(String.raw`\bi\s*(?:'d|would) (?:like|love) to work on ${ISSUE_OBJECT}`),
+  /\bi\s*(?:'m|am) on it\b/,
+  /\bi\s*(?:'ll|will) submit a pr\b/,
+  /\bassigned to me\b/
+];
+var GENERIC_WORKING_PATTERNS = [
+  /\bworking on (?:this|it)\b/,
+  /\bworking on a (?:fix|pr)\b/
 ];
+var PERMISSION_CLAIM_PATTERN = new RegExp(String.raw`\b(?:can|may|could) i (?:work on|take) ${ISSUE_OBJECT}`);
+var NON_CLAIM_SUBJECTS = /\b(?:anyone|anybody|someone|somebody|who|whoever|nobody|no[- ]?one|not)\b/;
+function commentClaimsIssue(body) {
+  const clauses = body.toLowerCase().split(/(?<=[.!?])|\n+/);
+  for (const clause of clauses) {
+    if (PERMISSION_CLAIM_PATTERN.test(clause))
+      return true;
+    if (clause.trimEnd().endsWith("?"))
+      continue;
+    if (FIRST_PERSON_CLAIM_PATTERNS.some((p) => p.test(clause)))
+      return true;
+    if (NON_CLAIM_SUBJECTS.test(clause))
+      continue;
+    if (GENERIC_WORKING_PATTERNS.some((p) => p.test(clause)))
+      return true;
+  }
+  return false;
+}
 async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
   try {
     const timeline = await paginateAll((page) => octokit.issues.listEventsForTimeline({
@@ -36572,67 +36727,68 @@ async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
     }
     return { passed: linkedPRCount === 0, linkedPR };
   } catch (error48) {
-    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
-      throw error48;
-    }
+    rethrowIfFatal(error48);
     const errMsg = errorMessage(error48);
     warn(MODULE5, `Failed to check for existing PRs on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming no existing PR.`);
     return { passed: true, inconclusive: true, reason: errMsg, linkedPR: null };
   }
 }
 var MERGED_PR_CACHE_TTL_MS = 15 * 60 * 1e3;
-async function checkUserMergedPRsInRepo(octokit, owner, repo) {
+async function checkUserMergedPRsInRepo(octokit, owner, repo, tracker = getSearchBudgetTracker()) {
   const cache = getHttpCache();
-  const cacheKey = `merged-prs:${owner}/${repo}`;
-  const cached2 = cache.getIfFresh(cacheKey, MERGED_PR_CACHE_TTL_MS);
-  if (cached2 != null && typeof cached2 === "number") {
-    return cached2;
-  }
-  try {
-    const tracker = getSearchBudgetTracker();
-    await tracker.waitForBudget();
-    try {
-      const { data } = await octokit.search.issuesAndPullRequests({
-        q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
-        per_page: 1
-        // We only need total_count
-      });
-      cache.set(cacheKey, "", data.total_count);
-      return data.total_count;
-    } finally {
-      tracker.recordCall();
+  const cacheKey = versionedCacheKey(`merged-prs:${owner}/${repo}`);
+  return withInflightDedup(cache, cacheKey, async () => {
+    const cached2 = cache.getIfFresh(cacheKey, MERGED_PR_CACHE_TTL_MS);
+    if (cached2 != null && typeof cached2 === "number") {
+      return cached2;
     }
-  } catch (error48) {
-    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
-      throw error48;
+    try {
+      await tracker.waitForBudget();
+      try {
+        const { data } = await octokit.search.issuesAndPullRequests({
+          q: `repo:${owner}/${repo} is:pr is:merged author:@me`,
+          per_page: 1
+          // We only need total_count
+        });
+        cache.set(cacheKey, "", data.total_count);
+        return data.total_count;
+      } finally {
+        tracker.recordCall();
+      }
+    } catch (error48) {
+      rethrowIfFatal(error48);
+      const errMsg = errorMessage(error48);
+      warn(MODULE5, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Treating as unknown.`);
+      return null;
     }
-    const errMsg = errorMessage(error48);
-    warn(MODULE5, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Defaulting to 0.`);
-    return 0;
-  }
+  });
 }
 async function checkNotClaimed(octokit, owner, repo, issueNumber, commentCount) {
   if (commentCount === 0)
     return { passed: true };
   try {
-    const comments = await octokit.paginate(octokit.issues.listComments, {
-      owner,
-      repo,
-      issue_number: issueNumber,
-      per_page: 100
-    }, (response) => response.data);
-    const recentComments = comments.slice(-100);
+    const PER_PAGE = 100;
+    const lastPage = Math.max(1, Math.ceil(commentCount / PER_PAGE));
+    const pagesToFetch = lastPage > 1 ? [lastPage - 1, lastPage] : [1];
+    const recentComments = [];
+    for (const page of pagesToFetch) {
+      const response = await octokit.issues.listComments({
+        owner,
+        repo,
+        issue_number: issueNumber,
+        per_page: PER_PAGE,
+        page
+      });
+      recentComments.push(...response.data);
+    }
     for (const comment of recentComments) {
-      const body = (comment.body || "").toLowerCase();
-      if (CLAIM_PHRASES.some((phrase) => body.includes(phrase))) {
+      if (commentClaimsIssue(comment.body || "")) {
         return { passed: false };
       }
     }
     return { passed: true };
   } catch (error48) {
-    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
-      throw error48;
-    }
+    rethrowIfFatal(error48);
     const errMsg = errorMessage(error48);
     warn(MODULE5, `Failed to check claim status on ${owner}/${repo}#${issueNumber}: ${errMsg}. Assuming not claimed.`);
     return { passed: true, inconclusive: true, reason: errMsg };
@@ -36653,8 +36809,30 @@ function analyzeRequirements(body) {
   return indicators.filter(Boolean).length >= 2;
 }
 
+// ../core/dist/core/probe-repo-file.js
+var MODULE6 = "probe-repo-file";
+async function probeRepoFile(octokit, owner, repo, path5) {
+  try {
+    const { data } = await octokit.repos.getContent({ owner, repo, path: path5 });
+    if (data && typeof data === "object" && "content" in data && typeof data.content === "string") {
+      return {
+        text: Buffer.from(data.content, "base64").toString("utf-8"),
+        transient: false
+      };
+    }
+    return { text: null, transient: false };
+  } catch (error48) {
+    const status = getHttpStatusCode(error48);
+    if (status === 404)
+      return { text: null, transient: false };
+    rethrowIfFatal(error48);
+    warn(MODULE6, `Unexpected error fetching ${path5} from ${owner}/${repo}: ${errorMessage(error48)}`);
+    return { text: null, transient: true };
+  }
+}
+
 // ../core/dist/core/repo-health.js
-var MODULE6 = "repo-health";
+var MODULE7 = "repo-health";
 var guidelinesCache = /* @__PURE__ */ new Map();
 var CACHE_TTL_MS = 60 * 60 * 1e3;
 var HEALTH_CACHE_TTL_MS = 4 * 60 * 60 * 1e3;
@@ -36705,19 +36883,11 @@ async function checkProjectHealth(octokit, owner, repo) {
       };
     });
   } catch (error48) {
-    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
-      throw error48;
-    }
+    rethrowIfFatal(error48);
     const errMsg = errorMessage(error48);
-    warn(MODULE6, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
+    warn(MODULE7, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
     return {
       repo: `${owner}/${repo}`,
-      lastCommitAt: "",
-      daysSinceLastCommit: 999,
-      openIssuesCount: 0,
-      avgIssueResponseDays: 0,
-      ciStatus: "unknown",
-      isActive: false,
       checkFailed: true,
       failureReason: errMsg
     };
@@ -36729,18 +36899,27 @@ async function fetchContributionGuidelines(octokit, owner, repo) {
   if (cached2 && Date.now() - cached2.fetchedAt < CACHE_TTL_MS) {
     return cached2.guidelines;
   }
+  const inflight = guidelinesInflight.get(cacheKey);
+  if (inflight)
+    return inflight;
+  const promise2 = fetchContributionGuidelinesUncached(octokit, owner, repo);
+  guidelinesInflight.set(cacheKey, promise2);
+  try {
+    return await promise2;
+  } finally {
+    guidelinesInflight.delete(cacheKey);
+  }
+}
+var guidelinesInflight = /* @__PURE__ */ new Map();
+async function fetchContributionGuidelinesUncached(octokit, owner, repo) {
+  const cacheKey = `${owner}/${repo}`;
   const filesToCheck = [
     "CONTRIBUTING.md",
     ".github/CONTRIBUTING.md",
     "docs/CONTRIBUTING.md",
     "contributing.md"
   ];
-  const results = await Promise.allSettled(filesToCheck.map((file2) => octokit.repos.getContent({ owner, repo, path: file2 }).then(({ data }) => {
-    if ("content" in data) {
-      return Buffer.from(data.content, "base64").toString("utf-8");
-    }
-    return null;
-  })));
+  const results = await Promise.allSettled(filesToCheck.map((file2) => probeRepoFile(octokit, owner, repo, file2)));
   for (const result of results) {
     if (result.status !== "rejected")
       continue;
@@ -36748,20 +36927,13 @@ async function fetchContributionGuidelines(octokit, owner, repo) {
       throw result.reason;
     }
   }
-  for (let i = 0; i < results.length; i++) {
-    const result = results[i];
-    if (result.status === "fulfilled" && result.value) {
-      const guidelines = parseContributionGuidelines(result.value);
+  for (const result of results) {
+    if (result.status === "fulfilled" && result.value.text) {
+      const guidelines = parseContributionGuidelines(result.value.text);
       guidelinesCache.set(cacheKey, { guidelines, fetchedAt: Date.now() });
       pruneCache();
       return guidelines;
     }
-    if (result.status === "rejected") {
-      const status = getHttpStatusCode(result.reason);
-      if (status !== 404) {
-        warn(MODULE6, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${errorMessage(result.reason)}`);
-      }
-    }
   }
   guidelinesCache.set(cacheKey, {
     guidelines: void 0,
@@ -36776,7 +36948,7 @@ function parseContributionGuidelines(content) {
   };
   const lowerContent = content.toLowerCase();
   if (lowerContent.includes("branch")) {
-    const branchMatch = content.match(/branch[^\n]*(?:named?|format|convention)[^\n]*[`"]([^`"]+)[`"]/i);
+    const branchMatch = content.match(/branch[^\n]{0,200}?(?:named?|format|convention)[^\n]{0,200}?[`"]([^`"\n]{1,100})[`"]/i);
     if (branchMatch) {
       guidelines.branchNamingConvention = branchMatch[1];
     }
@@ -36784,7 +36956,7 @@ function parseContributionGuidelines(content) {
   if (lowerContent.includes("conventional commit")) {
     guidelines.commitMessageFormat = "conventional commits";
   } else if (lowerContent.includes("commit message")) {
-    const commitMatch = content.match(/commit message[^\n]*[`"]([^`"]+)[`"]/i);
+    const commitMatch = content.match(/commit message[^\n]{0,200}?[`"]([^`"\n]{1,100})[`"]/i);
     if (commitMatch) {
       guidelines.commitMessageFormat = commitMatch[1];
     }
@@ -36803,14 +36975,13 @@ function parseContributionGuidelines(content) {
     guidelines.linter = "RuboCop";
   else if (lowerContent.includes("prettier"))
     guidelines.formatter = "Prettier";
-  if (lowerContent.includes("cla") || lowerContent.includes("contributor license agreement")) {
+  if (/\bcla\b/.test(lowerContent) || lowerContent.includes("contributor license agreement")) {
     guidelines.claRequired = true;
   }
   return guidelines;
 }
 
 // ../core/dist/core/anti-llm-policy.js
-var MODULE7 = "anti-llm-policy";
 var POLICY_SCAN_CACHE_TTL_MS = 60 * 60 * 1e3;
 var ANTI_LLM_KEYWORDS = [
   "no ai-generated",
@@ -36873,28 +37044,8 @@ var SOURCE_FILE_FAMILIES = [
     paths: ["README.md", "readme.md", "Readme.md"]
   }
 ];
-async function fetchFileText(octokit, owner, repo, path5) {
-  try {
-    const { data } = await octokit.repos.getContent({ owner, repo, path: path5 });
-    if ("content" in data && typeof data.content === "string") {
-      return {
-        text: Buffer.from(data.content, "base64").toString("utf-8"),
-        transient: false
-      };
-    }
-    return { text: null, transient: false };
-  } catch (error48) {
-    const status = getHttpStatusCode(error48);
-    if (status === 404)
-      return { text: null, transient: false };
-    if (status === 401 || isRateLimitError(error48))
-      throw error48;
-    warn(MODULE7, `Unexpected error fetching ${path5} from ${owner}/${repo}: ${errorMessage(error48)}`);
-    return { text: null, transient: true };
-  }
-}
 async function fetchFamilyText(octokit, owner, repo, paths) {
-  const results = await Promise.allSettled(paths.map((p) => fetchFileText(octokit, owner, repo, p)));
+  const results = await Promise.allSettled(paths.map((p) => probeRepoFile(octokit, owner, repo, p)));
   let hadTransientFailure = false;
   for (const result of results) {
     if (result.status === "fulfilled") {
@@ -36925,7 +37076,7 @@ function isAntiLLMPolicyResult(value) {
 }
 async function fetchAndScanAntiLLMPolicy(octokit, owner, repo, options) {
   const cache = getHttpCache();
-  const cacheKey = `anti-llm-policy:${owner}/${repo}`;
+  const cacheKey = versionedCacheKey(`anti-llm-policy:${owner}/${repo}`);
   const cached2 = cache.getIfFresh(cacheKey, POLICY_SCAN_CACHE_TTL_MS);
   if (isAntiLLMPolicyResult(cached2))
     return cached2;
@@ -36964,6 +37115,76 @@ async function fetchAndScanAntiLLMPolicy(octokit, owner, repo, options) {
   return noMatch;
 }
 
+// ../core/dist/core/issue-graphql.js
+var MODULE8 = "issue-graphql";
+function issueCoreKey(owner, repo, number4) {
+  return `${owner}/${repo}#${number4}`;
+}
+function normalizeNode(node) {
+  return {
+    id: node.databaseId,
+    title: node.title,
+    body: node.body ?? "",
+    state: node.state === "CLOSED" ? "closed" : "open",
+    labels: node.labels.nodes.map((l) => l.name),
+    commentCount: node.comments.totalCount,
+    createdAt: node.createdAt,
+    updatedAt: node.updatedAt
+  };
+}
+async function prefetchIssueCores(octokit, issues) {
+  const result = /* @__PURE__ */ new Map();
+  if (issues.length === 0)
+    return result;
+  const unique = [
+    ...new Map(issues.map((i) => [issueCoreKey(i.owner, i.repo, i.number), i])).values()
+  ];
+  const varDefs = [];
+  const selections = [];
+  const variables = {};
+  unique.forEach((iss, i) => {
+    varDefs.push(`$o${i}: String!, $n${i}: String!, $num${i}: Int!`);
+    variables[`o${i}`] = iss.owner;
+    variables[`n${i}`] = iss.repo;
+    variables[`num${i}`] = iss.number;
+    selections.push(`i${i}: repository(owner: $o${i}, name: $n${i}) {
+        issue(number: $num${i}) {
+          databaseId
+          title
+          body
+          state
+          labels(first: 100) { nodes { name } }
+          comments { totalCount }
+          createdAt
+          updatedAt
+        }
+      }`);
+  });
+  const query = `query batchIssueCores(${varDefs.join(", ")}) {
+${selections.join("\n")}
+}`;
+  let data;
+  try {
+    data = await octokit.graphql(query, variables);
+  } catch (err) {
+    rethrowIfFatal(err);
+    const partial2 = err.data;
+    if (partial2) {
+      data = partial2;
+    } else {
+      warn(MODULE8, `GraphQL prefetch failed, falling back to REST: ${errorMessage(err)}`);
+      return result;
+    }
+  }
+  unique.forEach((iss, i) => {
+    const node = data?.[`i${i}`]?.issue;
+    if (!node || node.databaseId == null)
+      return;
+    result.set(issueCoreKey(iss.owner, iss.repo, iss.number), normalizeNode(node));
+  });
+  return result;
+}
+
 // ../core/dist/core/slm-triage.js
 var DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
 var DEFAULT_TIMEOUT_MS = 15e3;
@@ -37076,15 +37297,96 @@ function isValidTriageShape(value) {
 }
 
 // ../core/dist/core/issue-vetting.js
-var MODULE8 = "issue-vetting";
+var MODULE9 = "issue-vetting";
 var MAX_CONCURRENT_VETTING = 3;
 var VETTING_CACHE_TTL_MS = 15 * 60 * 1e3;
+function deriveRecommendation(input) {
+  const notes = [];
+  const reasonsToApprove = [];
+  const reasonsToSkip = [];
+  if (!input.noExistingPR)
+    notes.push(input.ownPR ? "Your PR is already in flight for this issue" : "Existing PR found for this issue");
+  if (!input.notClaimed)
+    notes.push("Issue appears to be claimed by someone");
+  if (input.existingPRInconclusive) {
+    notes.push(`Could not verify absence of existing PRs: ${input.existingPRReason || "API error"}`);
+  }
+  if (input.claimInconclusive) {
+    notes.push(`Could not verify claim status: ${input.claimReason || "API error"}`);
+  }
+  if (input.projectCheckFailed) {
+    notes.push(`Could not verify project activity: ${input.projectFailureReason || "API error"}`);
+  } else if (!input.projectIsActive) {
+    notes.push("Project may be inactive");
+  }
+  if (!input.clearRequirements)
+    notes.push("Issue requirements are unclear");
+  if (!input.contributionGuidelinesFound)
+    notes.push("No CONTRIBUTING.md found");
+  if (!input.noExistingPR)
+    reasonsToSkip.push(input.ownPR ? "You already have a PR in flight" : "Has existing PR");
+  if (!input.notClaimed)
+    reasonsToSkip.push("Already claimed");
+  if (!input.projectIsActive && !input.projectCheckFailed)
+    reasonsToSkip.push("Inactive project");
+  if (!input.clearRequirements)
+    reasonsToSkip.push("Unclear requirements");
+  if (input.noExistingPR)
+    reasonsToApprove.push("No existing PR");
+  if (input.notClaimed)
+    reasonsToApprove.push("Not claimed");
+  if (input.projectIsActive && !input.projectCheckFailed)
+    reasonsToApprove.push("Active project");
+  if (input.clearRequirements)
+    reasonsToApprove.push("Clear requirements");
+  if (input.contributionGuidelinesFound)
+    reasonsToApprove.push("Has contribution guidelines");
+  if (input.effectiveMergedCount > 0) {
+    reasonsToApprove.push(`Trusted project (${input.effectiveMergedCount} PR${input.effectiveMergedCount > 1 ? "s" : ""} merged)`);
+  }
+  if (input.orgHasMergedPRs) {
+    reasonsToApprove.push(`Org affinity (merged PRs in other ${input.orgName} repos)`);
+  }
+  if (input.matchesCategory) {
+    reasonsToApprove.push("Matches preferred project category");
+  }
+  if (input.issueClosed) {
+    reasonsToSkip.push("Issue is closed");
+  }
+  let recommendation;
+  if (input.issueClosed) {
+    recommendation = "skip";
+  } else if (input.ownPR) {
+    recommendation = "skip";
+  } else if (input.passedAllChecks) {
+    recommendation = "approve";
+  } else if (reasonsToSkip.length > 2) {
+    recommendation = "skip";
+  } else {
+    recommendation = "needs_review";
+  }
+  const hasInconclusiveChecks = input.projectCheckFailed || input.existingPRInconclusive || input.claimInconclusive || input.mergedCountInconclusive;
+  if (recommendation === "approve" && hasInconclusiveChecks) {
+    recommendation = "needs_review";
+    notes.push("Recommendation downgraded: one or more checks were inconclusive");
+  }
+  return { notes, reasonsToApprove, reasonsToSkip, recommendation };
+}
 var IssueVetter = class {
   octokit;
   stateReader;
-  constructor(octokit, stateReader) {
+  budgetTracker;
+  /**
+   * @param octokit      - Authenticated Octokit instance
+   * @param stateReader  - Read-only scout state interface
+   * @param budgetTracker - Search budget tracker. Defaults to the shared
+   *   singleton so existing callers behave identically; inject a per-search
+   *   instance to isolate budget accounting in a long-lived concurrent host.
+   */
+  constructor(octokit, stateReader, budgetTracker = getSearchBudgetTracker()) {
     this.octokit = octokit;
     this.stateReader = stateReader;
+    this.budgetTracker = budgetTracker;
   }
   /**
    * Vet a specific issue — runs all checks and computes recommendation + viability score.
@@ -37098,10 +37400,10 @@ var IssueVetter = class {
   async vetIssue(issueUrl, opts) {
     const cache = getHttpCache();
     const sigKey = opts?.featureSignals ? `:r${opts.featureSignals.reactions}c${opts.featureSignals.comments}m${opts.featureSignals.hasMilestone ? 1 : 0}o${opts.featureSignals.onRoadmap ? 1 : 0}w${opts.featureSignals.wontfixNoContributor ? 1 : 0}` : "";
-    const cacheKey = `vet:${issueUrl}${sigKey}`;
+    const cacheKey = versionedCacheKey(`vet:${issueUrl}${sigKey}`);
     const cached2 = cache.getIfFresh(cacheKey, VETTING_CACHE_TTL_MS);
     if (cached2 && typeof cached2 === "object" && "issue" in cached2 && "viabilityScore" in cached2) {
-      debug(MODULE8, `Vetting cache hit for ${issueUrl}`);
+      debug(MODULE9, `Vetting cache hit for ${issueUrl}`);
       return cached2;
     }
     const parsed = parseGitHubUrl(issueUrl);
@@ -37110,24 +37412,23 @@ var IssueVetter = class {
     }
     const { owner, repo, number: number4 } = parsed;
     const repoFullName = `${owner}/${repo}`;
-    const { data: ghIssue } = await this.octokit.issues.get({
-      owner,
-      repo,
-      issue_number: number4
-    });
+    const core = opts?.prefetched ?? await this.fetchIssueCore(owner, repo, number4);
     const reposWithMergedPRs = this.stateReader.getReposWithMergedPRs();
     const hasMergedPRsInRepo = reposWithMergedPRs.includes(repoFullName);
     const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
       checkNoExistingPR(this.octokit, owner, repo, number4),
-      checkNotClaimed(this.octokit, owner, repo, number4, ghIssue.comments),
+      checkNotClaimed(this.octokit, owner, repo, number4, core.commentCount),
       checkProjectHealth(this.octokit, owner, repo),
       fetchContributionGuidelines(this.octokit, owner, repo),
-      hasMergedPRsInRepo ? Promise.resolve(0) : checkUserMergedPRsInRepo(this.octokit, owner, repo)
+      hasMergedPRsInRepo ? Promise.resolve(0) : checkUserMergedPRsInRepo(this.octokit, owner, repo, this.budgetTracker)
     ]);
     const antiLLMPolicy = await fetchAndScanAntiLLMPolicy(this.octokit, owner, repo, { contributingText: contributionGuidelines?.rawContent });
     const noExistingPR = existingPRCheck.passed;
     const notClaimed = claimCheck.passed;
-    const clearRequirements = analyzeRequirements(ghIssue.body || "");
+    const username = this.stateReader.getGitHubUsername?.() ?? "";
+    const linkedPR = existingPRCheck.linkedPR;
+    const ownPR = !noExistingPR && !!linkedPR && linkedPR.state === "open" && !linkedPR.merged && username !== "" && linkedPR.author.toLowerCase() === username.toLowerCase();
+    const clearRequirements = analyzeRequirements(core.body);
     const projectActive = projectHealth.checkFailed ? true : projectHealth.isActive;
     const vettingResult = {
       passedAllChecks: noExistingPR && notClaimed && projectActive && clearRequirements,
@@ -37142,89 +37443,52 @@ var IssueVetter = class {
       linkedPR: existingPRCheck.linkedPR,
       notes: []
     };
-    if (!noExistingPR)
-      vettingResult.notes.push("Existing PR found for this issue");
-    if (!notClaimed)
-      vettingResult.notes.push("Issue appears to be claimed by someone");
-    if (existingPRCheck.inconclusive) {
-      vettingResult.notes.push(`Could not verify absence of existing PRs: ${existingPRCheck.reason || "API error"}`);
-    }
-    if (claimCheck.inconclusive) {
-      vettingResult.notes.push(`Could not verify claim status: ${claimCheck.reason || "API error"}`);
-    }
-    if (projectHealth.checkFailed) {
-      vettingResult.notes.push(`Could not verify project activity: ${projectHealth.failureReason || "API error"}`);
-    } else if (!projectHealth.isActive) {
-      vettingResult.notes.push("Project may be inactive");
-    }
-    if (!clearRequirements)
-      vettingResult.notes.push("Issue requirements are unclear");
-    if (!contributionGuidelines)
-      vettingResult.notes.push("No CONTRIBUTING.md found");
     const trackedIssue = {
-      id: ghIssue.id,
+      id: core.id,
       url: issueUrl,
       repo: repoFullName,
       number: number4,
-      title: ghIssue.title,
+      title: core.title,
       status: "candidate",
-      labels: ghIssue.labels.map((l) => typeof l === "string" ? l : l.name || ""),
-      createdAt: ghIssue.created_at,
-      updatedAt: ghIssue.updated_at,
+      labels: core.labels,
+      createdAt: core.createdAt,
+      updatedAt: core.updatedAt,
       vetted: true,
       vettingResult
     };
-    const reasonsToSkip = [];
-    const reasonsToApprove = [];
-    if (!noExistingPR)
-      reasonsToSkip.push("Has existing PR");
-    if (!notClaimed)
-      reasonsToSkip.push("Already claimed");
-    if (!projectHealth.isActive && !projectHealth.checkFailed)
-      reasonsToSkip.push("Inactive project");
-    if (!clearRequirements)
-      reasonsToSkip.push("Unclear requirements");
-    if (noExistingPR)
-      reasonsToApprove.push("No existing PR");
-    if (notClaimed)
-      reasonsToApprove.push("Not claimed");
-    if (projectHealth.isActive && !projectHealth.checkFailed)
-      reasonsToApprove.push("Active project");
-    if (clearRequirements)
-      reasonsToApprove.push("Clear requirements");
-    if (contributionGuidelines)
-      reasonsToApprove.push("Has contribution guidelines");
-    const effectiveMergedCount = hasMergedPRsInRepo ? 1 : userMergedPRCount;
-    if (effectiveMergedCount > 0) {
-      reasonsToApprove.push(`Trusted project (${effectiveMergedCount} PR${effectiveMergedCount > 1 ? "s" : ""} merged)`);
-    }
+    const mergedCountInconclusive = !hasMergedPRsInRepo && userMergedPRCount === null;
+    const effectiveMergedCount = hasMergedPRsInRepo ? 1 : userMergedPRCount ?? 0;
     const orgName = repoFullName.split("/")[0];
     let orgHasMergedPRs = false;
     if (orgName && repoFullName.includes("/")) {
       orgHasMergedPRs = reposWithMergedPRs.some((r) => r.startsWith(orgName + "/") && r !== repoFullName);
     }
-    if (orgHasMergedPRs) {
-      reasonsToApprove.push(`Org affinity (merged PRs in other ${orgName} repos)`);
-    }
-    const projectCategories = this.stateReader.getProjectCategories();
-    const matchesCategory = repoBelongsToCategory(repoFullName, projectCategories);
-    if (matchesCategory) {
-      reasonsToApprove.push("Matches preferred project category");
-    }
-    let recommendation;
-    if (vettingResult.passedAllChecks) {
-      recommendation = "approve";
-    } else if (reasonsToSkip.length > 2) {
-      recommendation = "skip";
-    } else {
-      recommendation = "needs_review";
-    }
-    const hasInconclusiveChecks = projectHealth.checkFailed || existingPRCheck.inconclusive || claimCheck.inconclusive;
-    if (recommendation === "approve" && hasInconclusiveChecks) {
-      recommendation = "needs_review";
-      vettingResult.notes.push("Recommendation downgraded: one or more checks were inconclusive");
-    }
-    const repoQualityBonus = calculateRepoQualityBonus(projectHealth.stargazersCount ?? 0, projectHealth.forksCount ?? 0);
+    const matchesCategory = repoBelongsToCategory(repoFullName, this.stateReader.getProjectCategories());
+    const issueClosed = core.state === "closed";
+    const hasInconclusiveChecks = projectHealth.checkFailed || !!existingPRCheck.inconclusive || !!claimCheck.inconclusive || mergedCountInconclusive;
+    const { notes, reasonsToApprove, reasonsToSkip, recommendation } = deriveRecommendation({
+      noExistingPR,
+      ownPR,
+      notClaimed,
+      clearRequirements,
+      contributionGuidelinesFound: !!contributionGuidelines,
+      projectIsActive: projectHealth.checkFailed ? false : projectHealth.isActive,
+      projectCheckFailed: !!projectHealth.checkFailed,
+      projectFailureReason: projectHealth.failureReason,
+      existingPRInconclusive: !!existingPRCheck.inconclusive,
+      existingPRReason: existingPRCheck.inconclusive ? existingPRCheck.reason : void 0,
+      claimInconclusive: !!claimCheck.inconclusive,
+      claimReason: claimCheck.inconclusive ? claimCheck.reason : void 0,
+      mergedCountInconclusive,
+      effectiveMergedCount,
+      orgName,
+      orgHasMergedPRs,
+      matchesCategory,
+      issueClosed,
+      passedAllChecks: vettingResult.passedAllChecks
+    });
+    vettingResult.notes = notes;
+    const repoQualityBonus = projectHealth.checkFailed ? 0 : calculateRepoQualityBonus(projectHealth.stargazersCount ?? 0, projectHealth.forksCount ?? 0);
     if (projectHealth.checkFailed && repoQualityBonus === 0) {
       vettingResult.notes.push("Repo quality bonus unavailable: could not fetch star/fork counts due to API error");
     }
@@ -37235,8 +37499,8 @@ var IssueVetter = class {
       isClaimed: !notClaimed,
       clearRequirements,
       hasContributionGuidelines: !!contributionGuidelines,
-      issueUpdatedAt: ghIssue.updated_at,
-      closedWithoutMergeCount: 0,
+      issueUpdatedAt: core.updatedAt,
+      closedWithoutMergeCount: this.stateReader.getClosedWithoutMergeCount?.(repoFullName) ?? 0,
       mergedPRCount: effectiveMergedCount,
       orgHasMergedPRs,
       repoQualityBonus,
@@ -37250,22 +37514,20 @@ var IssueVetter = class {
     } else if (starredRepos.includes(repoFullName)) {
       searchPriority = "starred";
     }
-    const slmConfig = this.stateReader.getSLMTriageConfig?.() ?? {
-      model: "",
-      host: ""
-    };
+    const slmConfig = this.stateReader.getSLMTriageConfig();
     let slmTriage = null;
-    if (slmConfig.model) {
+    if (slmConfig) {
       const slmOpts = { model: slmConfig.model };
       if (slmConfig.host)
         slmOpts.host = slmConfig.host;
       slmTriage = await triageWithSLM(buildTriageInput({
-        issue: { ...trackedIssue, body: ghIssue.body ?? "" },
+        issue: { ...trackedIssue, body: core.body },
         linkedPR: existingPRCheck.linkedPR ?? null
       }), slmOpts);
     }
     const result = {
       issue: trackedIssue,
+      issueState: issueClosed ? "closed" : "open",
       vettingResult,
       projectHealth,
       antiLLMPolicy,
@@ -37276,9 +37538,33 @@ var IssueVetter = class {
       viabilityScore,
       searchPriority
     };
-    cache.set(cacheKey, "", result);
+    if (!hasInconclusiveChecks) {
+      cache.set(cacheKey, "", result);
+    }
     return result;
   }
+  /**
+   * Fetch a single issue's core fields via REST and normalize them to the same
+   * shape as a GraphQL prefetch (#169). The REST fallback path when no
+   * prefetched core was supplied.
+   */
+  async fetchIssueCore(owner, repo, number4) {
+    const { data: ghIssue } = await this.octokit.issues.get({
+      owner,
+      repo,
+      issue_number: number4
+    });
+    return {
+      id: ghIssue.id,
+      title: ghIssue.title,
+      body: ghIssue.body || "",
+      state: ghIssue.state === "closed" ? "closed" : "open",
+      labels: ghIssue.labels.map((l) => typeof l === "string" ? l : l.name || ""),
+      commentCount: ghIssue.comments,
+      createdAt: ghIssue.created_at,
+      updatedAt: ghIssue.updated_at
+    };
+  }
   /**
    * Vet multiple issues in parallel with concurrency limit
    */
@@ -37289,13 +37575,23 @@ var IssueVetter = class {
     let rateLimitFailures = 0;
     let attemptedCount = 0;
     let firstAuthError = null;
-    for (const url2 of urls) {
+    const uniqueUrls = [...new Set(urls)];
+    const prefetched = await prefetchIssueCores(this.octokit, uniqueUrls.flatMap((url2) => {
+      const p = parseGitHubUrl(url2);
+      return p && p.type === "issues" ? [{ owner: p.owner, repo: p.repo, number: p.number }] : [];
+    }));
+    const prefetchFor = (url2) => {
+      const p = parseGitHubUrl(url2);
+      return p && p.type === "issues" ? prefetched.get(issueCoreKey(p.owner, p.repo, p.number)) : void 0;
+    };
+    for (const url2 of uniqueUrls) {
       if (candidates.length >= maxResults)
         break;
       if (firstAuthError)
         break;
       attemptedCount++;
-      const task = this.vetIssue(url2).then((candidate) => {
+      const core = prefetchFor(url2);
+      const task = this.vetIssue(url2, core ? { prefetched: core } : void 0).then((candidate) => {
         if (candidates.length < maxResults) {
           if (priority) {
             candidate.searchPriority = priority;
@@ -37311,7 +37607,7 @@ var IssueVetter = class {
         if (isRateLimitError(error48)) {
           rateLimitFailures++;
         }
-        warn(MODULE8, `Error vetting issue ${url2}:`, errorMessage(error48));
+        warn(MODULE9, `Error vetting issue ${url2}:`, errorMessage(error48));
       }).finally(() => pending.delete(url2));
       pending.set(url2, task);
       if (pending.size >= MAX_CONCURRENT_VETTING) {
@@ -37321,13 +37617,13 @@ var IssueVetter = class {
     await Promise.allSettled(pending.values());
     if (firstAuthError) {
       if (candidates.length > 0) {
-        warn(MODULE8, `Auth failed mid-batch after ${candidates.length} successful vet(s) \u2014 discarding partial results`);
+        warn(MODULE9, `Auth failed mid-batch after ${candidates.length} successful vet(s) \u2014 discarding partial results`);
       }
       throw firstAuthError;
     }
     const allFailed = failedVettingCount === attemptedCount && attemptedCount > 0;
     if (allFailed) {
-      warn(MODULE8, `All ${attemptedCount} issue(s) failed vetting. This may indicate a systemic issue (rate limit, auth, network).`);
+      warn(MODULE9, `All ${attemptedCount} issue(s) failed vetting. This may indicate a systemic issue (rate limit, auth, network).`);
     }
     return {
       candidates: candidates.slice(0, maxResults),
@@ -37338,14 +37634,14 @@ var IssueVetter = class {
 };
 
 // ../core/dist/core/search-phases.js
-var MODULE9 = "search-phases";
+var MODULE10 = "search-phases";
 var GITHUB_MAX_BOOLEAN_OPS = 5;
 var INTER_QUERY_DELAY_MS = 2e3;
 function chunkLabels(labels, reservedOps = 0) {
   const maxPerChunk = GITHUB_MAX_BOOLEAN_OPS - reservedOps + 1;
   if (maxPerChunk < 1) {
     if (labels.length > 0) {
-      warn(MODULE9, `Label filtering disabled: ${reservedOps} repo/org ORs exceed GitHub's ${GITHUB_MAX_BOOLEAN_OPS} operator limit. All ${labels.length} label(s) dropped from query.`);
+      warn(MODULE10, `Label filtering disabled: ${reservedOps} repo/org ORs exceed GitHub's ${GITHUB_MAX_BOOLEAN_OPS} operator limit. All ${labels.length} label(s) dropped from query.`);
     }
     return [[]];
   }
@@ -37355,7 +37651,7 @@ function chunkLabels(labels, reservedOps = 0) {
   for (let i = 0; i < labels.length; i += maxPerChunk) {
     chunks.push(labels.slice(i, i + maxPerChunk));
   }
-  debug(MODULE9, `Split ${labels.length} labels into ${chunks.length} chunks (${reservedOps} ops reserved, max ${maxPerChunk} per chunk)`);
+  debug(MODULE10, `Split ${labels.length} labels into ${chunks.length} chunks (${reservedOps} ops reserved, max ${maxPerChunk} per chunk)`);
   return chunks;
 }
 function buildLabelQuery(labels) {
@@ -37387,15 +37683,14 @@ function interleaveArrays(arrays) {
   return result;
 }
 var SEARCH_CACHE_TTL_MS = 15 * 60 * 1e3;
-async function cachedSearchIssues(octokit, params) {
-  const cacheKey = `search:${params.q}:${params.sort}:${params.order}:${params.per_page}`;
+async function cachedSearchIssues(octokit, params, tracker = getSearchBudgetTracker()) {
+  const cacheKey = versionedCacheKey(`search:${params.q}:${params.sort}:${params.order}:${params.per_page}`);
   const cache = getHttpCache();
   const cached2 = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
   if (cached2) {
-    debug(MODULE9, `Search cache hit for query`);
+    debug(MODULE10, `Search cache hit for query`);
     return cached2;
   }
-  const tracker = getSearchBudgetTracker();
   await tracker.waitForBudget();
   let data;
   try {
@@ -37407,7 +37702,7 @@ async function cachedSearchIssues(octokit, params) {
   if (data.items.length > 0) {
     cache.set(cacheKey, "", data);
   } else {
-    debug(MODULE9, `Skipping cache for empty search result (possible rate limit artifact)`);
+    debug(MODULE10, `Skipping cache for empty search result (possible rate limit artifact)`);
   }
   return data;
 }
@@ -37455,10 +37750,10 @@ async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, maxResul
       if (getHttpStatusCode(error48) === 401)
         throw error48;
       if (isRateLimitError(error48)) {
-        warn(MODULE9, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error48));
+        warn(MODULE10, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error48));
         break;
       }
-      warn(MODULE9, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
+      warn(MODULE10, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
     }
   }
   return items;
@@ -37475,16 +37770,27 @@ async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResu
     const repoFullName = repos[i];
     const [owner, repo] = repoFullName.split("/");
     try {
-      const response = await octokit.issues.listForRepo({
-        owner,
-        repo,
-        state: "open",
-        sort: "created",
-        direction: "desc",
-        per_page: 5,
-        ...labels.length > 0 ? { labels: labels.join(",") } : {}
-      });
-      const issuesOnly = response.data.filter((item) => !("pull_request" in item) && !item.assignee);
+      const labelFilters = labels.length > 0 ? labels : [void 0];
+      const seenUrls = /* @__PURE__ */ new Set();
+      const rawIssues = [];
+      for (const label of labelFilters) {
+        const response = await octokit.issues.listForRepo({
+          owner,
+          repo,
+          state: "open",
+          sort: "created",
+          direction: "desc",
+          per_page: 5,
+          ...label !== void 0 ? { labels: label } : {}
+        });
+        for (const issue2 of response.data) {
+          if (seenUrls.has(issue2.html_url))
+            continue;
+          seenUrls.add(issue2.html_url);
+          rawIssues.push(issue2);
+        }
+      }
+      const issuesOnly = rawIssues.filter((item) => !("pull_request" in item) && !item.assignee);
       const mapped = issuesOnly.map((issue2) => ({
         html_url: issue2.html_url,
         repository_url: `https://api.github.com/repos/${repoFullName}`,
@@ -37509,17 +37815,17 @@ async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResu
       if (isRateLimitError(error48)) {
         rateLimitFailures++;
       }
-      warn(MODULE9, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
+      warn(MODULE10, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
     }
   }
   const allReposFailed = failedRepos === repos.length && repos.length > 0;
   const rateLimitHit = rateLimitFailures > 0;
   if (allReposFailed) {
-    warn(MODULE9, `All ${repos.length} repo(s) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
+    warn(MODULE10, `All ${repos.length} repo(s) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
   }
   return { candidates, allReposFailed, rateLimitHit };
 }
-async function searchWithChunkedLabels(octokit, labels, reservedOps, buildQuery, perPage) {
+async function searchWithChunkedLabels(octokit, labels, reservedOps, buildQuery, perPage, tracker = getSearchBudgetTracker()) {
   const labelChunks = chunkLabels(labels, reservedOps);
   const seenUrls = /* @__PURE__ */ new Set();
   const allItems = [];
@@ -37532,7 +37838,7 @@ async function searchWithChunkedLabels(octokit, labels, reservedOps, buildQuery,
       sort: "created",
       order: "desc",
       per_page: perPage
-    });
+    }, tracker);
     for (const item of data.items) {
       if (!seenUrls.has(item.html_url)) {
         seenUrls.add(item.html_url);
@@ -37551,14 +37857,14 @@ function buildLanguageVariants(languages, isAnyLanguage, hasLabels) {
     return [languages.map((l) => `language:${l}`).join(" ")];
   return languages.map((l) => `language:${l}`);
 }
-async function searchAcrossLanguagesAndLabels(octokit, languages, isAnyLanguage, labels, buildBaseQuery, perPage) {
+async function searchAcrossLanguagesAndLabels(octokit, languages, isAnyLanguage, labels, buildBaseQuery, perPage, tracker = getSearchBudgetTracker()) {
   const langVariants = buildLanguageVariants(languages, isAnyLanguage, labels.length > 0);
   const seenUrls = /* @__PURE__ */ new Set();
   const allItems = [];
   for (let i = 0; i < langVariants.length; i++) {
     if (i > 0)
       await sleep(INTER_QUERY_DELAY_MS);
-    const items = await searchWithChunkedLabels(octokit, labels, 0, (labelQ) => `${buildBaseQuery(langVariants[i])} ${labelQ}`.replace(/  +/g, " ").trim(), perPage);
+    const items = await searchWithChunkedLabels(octokit, labels, 0, (labelQ) => `${buildBaseQuery(langVariants[i])} ${labelQ}`.replace(/  +/g, " ").trim(), perPage, tracker);
     for (const item of items) {
       if (!seenUrls.has(item.html_url)) {
         seenUrls.add(item.html_url);
@@ -37572,7 +37878,7 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
   const spamRepos = detectLabelFarmingRepos(items);
   if (spamRepos.size > 0) {
     const spamCount = items.filter((i) => spamRepos.has(extractRepoFromUrl(i.repository_url) ?? "")).length;
-    debug(MODULE9, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(", ")}`);
+    debug(MODULE10, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(", ")}`);
   }
   const itemsToVet = filterIssues(items).filter((item) => {
     const repoFullName = extractRepoFromUrl(item.repository_url);
@@ -37583,7 +37889,7 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
     return excludedRepoSets.every((s) => !s.has(repoFullName));
   }).slice(0, remainingNeeded * 2);
   if (itemsToVet.length === 0) {
-    debug(MODULE9, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
+    debug(MODULE10, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
     return { candidates: [], allVetFailed: false, rateLimitHit: false };
   }
   const { candidates: results, allFailed: allVetFailed, rateLimitHit } = await vetter.vetIssuesParallel(itemsToVet.map((i) => i.html_url), remainingNeeded, "normal");
@@ -37595,7 +37901,7 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
   });
   const starFilteredCount = results.length - starFiltered.length;
   if (starFilteredCount > 0) {
-    debug(MODULE9, `[STAR_FILTER] Filtered ${starFilteredCount} ${phaseLabel} candidates below ${minStars} stars`);
+    debug(MODULE10, `[STAR_FILTER] Filtered ${starFilteredCount} ${phaseLabel} candidates below ${minStars} stars`);
   }
   return { candidates: starFiltered, allVetFailed, rateLimitHit };
 }
@@ -37603,28 +37909,50 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
 // ../core/dist/core/personalization.js
 var REPO_BOOST = 20;
 var LANGUAGE_BOOST = 10;
-function annotateBoost(candidates, preferLanguages, preferRepos) {
-  const langSet = new Set((preferLanguages ?? []).map((l) => l.trim().toLowerCase()).filter(Boolean));
-  const repoSet = new Set((preferRepos ?? []).map((r) => r.trim()).filter(Boolean));
-  if (langSet.size === 0 && repoSet.size === 0)
-    return;
-  for (const c of candidates) {
+var ISSUE_TYPE_BOOST = 10;
+var AVOID_PENALTY = 15;
+function boostScoreOf(candidate) {
+  return candidate.personalization?.kind === "boosted" ? candidate.personalization.score : 0;
+}
+function normalizeSet(values) {
+  return new Set((values ?? []).map((v) => v.trim().toLowerCase()).filter(Boolean));
+}
+function annotateBoost(candidates, bias = {}) {
+  const langSet = normalizeSet(bias.preferLanguages);
+  const repoSet = normalizeSet(bias.preferRepos);
+  const avoidSet = normalizeSet(bias.avoidRepos);
+  const typeSet = normalizeSet(bias.boostIssueTypes);
+  if (langSet.size === 0 && repoSet.size === 0 && avoidSet.size === 0 && typeSet.size === 0) {
+    return candidates;
+  }
+  return candidates.map((c) => {
     let score = 0;
     const reasons = [];
-    if (repoSet.size > 0 && repoSet.has(c.issue.repo)) {
+    const repoLower = c.issue.repo.toLowerCase();
+    if (repoSet.size > 0 && repoSet.has(repoLower)) {
       score += REPO_BOOST;
       reasons.push(`repo affinity: ${c.issue.repo}`);
     }
-    const lang = c.projectHealth.language;
+    const lang = c.projectHealth.checkFailed ? null : c.projectHealth.language;
     if (langSet.size > 0 && lang && langSet.has(lang.toLowerCase())) {
       score += LANGUAGE_BOOST;
       reasons.push(`language match: ${lang}`);
     }
-    if (score > 0) {
-      c.boostScore = score;
-      c.boostReasons = reasons;
+    if (typeSet.size > 0) {
+      const matched = c.issue.labels.find((l) => typeSet.has(l.toLowerCase()));
+      if (matched) {
+        score += ISSUE_TYPE_BOOST;
+        reasons.push(`issue type: ${matched}`);
+      }
+    }
+    if (avoidSet.size > 0 && avoidSet.has(repoLower)) {
+      score -= AVOID_PENALTY;
+      reasons.push(`avoided repo: ${c.issue.repo}`);
     }
-  }
+    if (reasons.length === 0)
+      return c;
+    return { ...c, personalization: { kind: "boosted", score, reasons } };
+  });
 }
 function applyDiversityRatio(candidates, maxResults, diversityRatio) {
   if (maxResults <= 0)
@@ -37649,10 +37977,9 @@ function applyDiversityRatio(candidates, maxResults, diversityRatio) {
       break;
     if (seen.has(c.issue.url))
       continue;
-    if (c.boostScore && c.boostScore > 0)
+    if (boostScoreOf(c) !== 0)
       continue;
-    c.diversitySlot = true;
-    picks.push(c);
+    picks.push({ ...c, personalization: { kind: "diversity" } });
     seen.add(c.issue.url);
   }
   for (const c of candidates) {
@@ -37667,7 +37994,7 @@ function applyDiversityRatio(candidates, maxResults, diversityRatio) {
 }
 
 // ../core/dist/core/issue-discovery.js
-var MODULE10 = "issue-discovery";
+var MODULE11 = "issue-discovery";
 var LOW_BUDGET_THRESHOLD = 20;
 var CRITICAL_BUDGET_THRESHOLD = 10;
 function buildIssueFilter(config2) {
@@ -37676,16 +38003,17 @@ function buildIssueFilter(config2) {
       const repoFullName = extractRepoFromUrl(item.repository_url);
       if (!repoFullName)
         return false;
-      if (config2.excludedRepos.has(repoFullName))
+      const repoLower = repoFullName.toLowerCase();
+      if (config2.excludedRepos.has(repoLower))
         return false;
       if (config2.excludeOrgs.size > 0) {
-        const orgName = repoFullName.split("/")[0]?.toLowerCase();
+        const orgName = repoLower.split("/")[0];
         if (orgName && config2.excludeOrgs.has(orgName))
           return false;
       }
-      if (config2.aiBlocklisted.has(repoFullName))
+      if (config2.aiBlocklisted.has(repoLower))
         return false;
-      if (config2.lowScoringRepos.has(repoFullName))
+      if (config2.lowScoringRepos.has(repoLower))
         return false;
       if (config2.skippedUrls.has(item.html_url))
         return false;
@@ -37700,9 +38028,9 @@ function buildIssueFilter(config2) {
   };
 }
 async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
-  info(MODULE10, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
+  info(MODULE11, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
   const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues);
-  info(MODULE10, `Found ${candidates.length} candidates from merged-PR repos`);
+  info(MODULE11, `Found ${candidates.length} candidates from merged-PR repos`);
   return {
     candidates,
     error: allReposFailed ? "All merged-PR repo fetches failed" : null,
@@ -37710,26 +38038,26 @@ async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
   };
 }
 async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssues) {
-  info(MODULE10, `Phase 1: Searching issues in ${repos.length} starred repos...`);
+  info(MODULE11, `Phase 1: Searching issues in ${repos.length} starred repos...`);
   const phase1Labels = labels.slice(0, 3);
   const reposToSearch = repos.slice(0, 10);
   const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, reposToSearch, phase1Labels, maxResults, "starred", filterIssues);
-  info(MODULE10, `Found ${candidates.length} candidates from starred repos`);
+  info(MODULE11, `Found ${candidates.length} candidates from starred repos`);
   return {
     candidates,
     error: allReposFailed ? "All starred repo fetches failed" : null,
     rateLimitHit
   };
 }
-async function runPhase2(octokit, vetter, scopes, labels, configLabels, languages, isAnyLanguage, maxResults, minStars, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues) {
-  info(MODULE10, "Phase 2: General issue search...");
+async function runPhase2(octokit, vetter, scopes, labels, configLabels, languages, isAnyLanguage, maxResults, minStars, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues, tracker) {
+  info(MODULE11, "Phase 2: General issue search...");
   const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
   const tierLabelGroups = [];
   if (scopes && scopes.length > 1) {
     for (const scope of scopes) {
       const scopeLabels = SCOPE_LABELS[scope] ?? [];
       if (scopeLabels.length === 0) {
-        warn(MODULE10, `Scope "${scope}" has no labels, skipping tier`);
+        warn(MODULE11, `Scope "${scope}" has no labels, skipping tier`);
         continue;
       }
       tierLabelGroups.push({ tier: scope, tierLabels: scopeLabels });
@@ -37748,8 +38076,8 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
   let rateLimitHit = false;
   for (const { tier, tierLabels } of tierLabelGroups) {
     try {
-      const allItems = await searchAcrossLanguagesAndLabels(octokit, languages, isAnyLanguage, tierLabels, (langQ) => `is:issue is:open ${langQ} no:assignee`.replace(/  +/g, " ").trim(), budgetPerTier * 3);
-      info(MODULE10, `Phase 2 [${tier}]: processing ${allItems.length} items...`);
+      const allItems = await searchAcrossLanguagesAndLabels(octokit, languages, isAnyLanguage, tierLabels, (langQ) => `is:issue is:open ${langQ} no:assignee`.replace(/  +/g, " ").trim(), budgetPerTier * 3, tracker);
+      info(MODULE11, `Phase 2 [${tier}]: processing ${allItems.length} items...`);
       const { candidates: tierCandidates, allVetFailed, rateLimitHit: vetRateLimitHit } = await filterVetAndScore(vetter, allItems, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], budgetPerTier, minStars, `Phase 2 [${tier}]`);
       tierResults.push(tierCandidates);
       for (const c of tierCandidates)
@@ -37760,7 +38088,7 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
       if (vetRateLimitHit) {
         rateLimitHit = true;
       }
-      info(MODULE10, `Found ${tierCandidates.length} candidates from ${tier} tier`);
+      info(MODULE11, `Found ${tierCandidates.length} candidates from ${tier} tier`);
     } catch (err) {
       if (getHttpStatusCode(err) === 401)
         throw err;
@@ -37769,13 +38097,13 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
       if (isRateLimitError(err)) {
         rateLimitHit = true;
       }
-      warn(MODULE10, `Error in ${tier} tier search: ${errMsg}`);
+      warn(MODULE11, `Error in ${tier} tier search: ${errMsg}`);
       tierResults.push([]);
     }
   }
   const interleaved = interleaveArrays(tierResults);
   if (interleaved.length === 0 && error48) {
-    warn(MODULE10, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error48}`);
+    warn(MODULE11, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error48}`);
   }
   return {
     candidates: interleaved.slice(0, maxResults),
@@ -37783,18 +38111,18 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
     rateLimitHit
   };
 }
-async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues) {
-  info(MODULE10, "Phase 3: Searching actively maintained repos...");
+async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues, tracker) {
+  info(MODULE11, "Phase 3: Searching actively maintained repos...");
   const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
   const eligibleStarred = starredRepos.filter((r) => !phase0RepoSet.has(r) && !seenRepos.has(r));
   if (eligibleStarred.length > 0) {
-    info(MODULE10, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
+    info(MODULE11, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
     const restItems = await fetchIssuesFromMaintainedRepos(octokit, eligibleStarred.slice(0, 15), minStars, maxResults);
     if (restItems.length > 0) {
       try {
         const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit } = await filterVetAndScore(vetter, restItems, filterIssues, [phase0RepoSet, seenRepos], maxResults, minStars, "Phase 3 (REST)");
         if (candidates.length > 0) {
-          info(MODULE10, `Found ${candidates.length} candidates from maintained-repo REST search`);
+          info(MODULE11, `Found ${candidates.length} candidates from maintained-repo REST search`);
           return {
             candidates,
             error: allVetFailed ? "all vetting failed" : null,
@@ -37804,11 +38132,11 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       } catch (error48) {
         if (getHttpStatusCode(error48) === 401)
           throw error48;
-        warn(MODULE10, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error48));
+        warn(MODULE11, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error48));
       }
     }
   }
-  info(MODULE10, "Phase 3: Falling back to Search API...");
+  info(MODULE11, "Phase 3: Falling back to Search API...");
   const thirtyDaysAgo = /* @__PURE__ */ new Date();
   thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
   const pushedSince = thirtyDaysAgo.toISOString().split("T")[0];
@@ -37821,10 +38149,10 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       sort: "updated",
       order: "desc",
       per_page: maxResults * 3
-    });
-    info(MODULE10, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
+    }, tracker);
+    info(MODULE11, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
     const { candidates, allVetFailed, rateLimitHit: vetRateLimitHit } = await filterVetAndScore(vetter, data.items, filterIssues, [phase0RepoSet, starredRepoSet, seenRepos], maxResults, minStars, "Phase 3");
-    info(MODULE10, `Found ${candidates.length} candidates from maintained-repo search`);
+    info(MODULE11, `Found ${candidates.length} candidates from maintained-repo search`);
     return {
       candidates,
       error: allVetFailed ? "all vetting failed" : null,
@@ -37834,7 +38162,7 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
     if (getHttpStatusCode(error48) === 401)
       throw error48;
     const errMsg = errorMessage(error48);
-    warn(MODULE10, `Error in maintained-repo search: ${errMsg}`);
+    warn(MODULE11, `Error in maintained-repo search: ${errMsg}`);
     return {
       candidates: [],
       error: errMsg,
@@ -37848,19 +38176,26 @@ var IssueDiscovery = class {
   octokit;
   githubToken;
   vetter;
+  budgetTracker;
   /** Set after searchIssues() runs if rate limits affected the search (low pre-flight quota or mid-search rate limit hits). */
   rateLimitWarning = null;
   /**
    * @param githubToken  - GitHub personal access token or token from `gh auth token`
    * @param preferences  - User's search preferences (languages, labels, scopes, etc.)
    * @param stateReader  - Read-only interface for accessing scout state (merged PRs, starred repos, etc.)
+   * @param budgetTracker - Search budget tracker. Defaults to the shared
+   *   singleton so existing callers behave identically. A long-lived host
+   *   serving concurrent searches can inject a per-search instance so one
+   *   search's init() no longer resets the budget state of another (the
+   *   shared-singleton concurrency hazard, #156).
    */
-  constructor(githubToken, preferences, stateReader) {
+  constructor(githubToken, preferences, stateReader, budgetTracker = getSearchBudgetTracker()) {
     this.preferences = preferences;
     this.stateReader = stateReader;
     this.githubToken = githubToken;
     this.octokit = getOctokit(githubToken);
-    this.vetter = new IssueVetter(this.octokit, this.stateReader);
+    this.budgetTracker = budgetTracker;
+    this.vetter = new IssueVetter(this.octokit, this.stateReader, this.budgetTracker);
   }
   /**
    * Get starred repos from the state reader.
@@ -37900,16 +38235,29 @@ var IssueDiscovery = class {
     const labels = options.labels || (scopes ? buildEffectiveLabels(scopes, config2.labels) : config2.labels);
     const maxResults = options.maxResults || 10;
     const minStars = config2.minStars ?? 50;
-    const interPhaseDelay = config2.interPhaseDelayMs ?? 3e4;
+    const interPhaseDelay = options.interPhaseDelayMs ?? config2.interPhaseDelayMs ?? 3e4;
     const ALL_STRATEGIES = CONCRETE_STRATEGIES;
-    const rawStrategies = options.strategies ?? config2.defaultStrategy ?? ["all"];
+    const pickStrategies = (...candidates) => candidates.find((c) => c && c.length > 0) ?? ["all"];
+    const rawStrategies = pickStrategies(options.strategies, config2.defaultStrategy);
     const enabledStrategies = new Set(rawStrategies.includes("all") ? ALL_STRATEGIES : rawStrategies);
     const strategiesUsed = [];
     const allCandidates = [];
     const phaseErrors = {};
     let rateLimitHitDuringSearch = false;
+    const applyInterPhaseDelay = async () => {
+      if (interPhaseDelay > 0) {
+        info(MODULE11, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        await sleep(interPhaseDelay);
+      }
+    };
+    const recordPhaseResult = (key, result) => {
+      allCandidates.push(...result.candidates);
+      phaseErrors[key] = result.error;
+      if (result.rateLimitHit)
+        rateLimitHitDuringSearch = true;
+    };
     this.rateLimitWarning = null;
-    const tracker = getSearchBudgetTracker();
+    const tracker = this.budgetTracker;
     let searchBudget = LOW_BUDGET_THRESHOLD - 1;
     try {
       const rateLimit = await checkRateLimit(this.githubToken);
@@ -37918,18 +38266,18 @@ var IssueDiscovery = class {
       if (rateLimit.remaining < 5) {
         const resetTime = new Date(rateLimit.resetAt).toLocaleTimeString("en-US", { hour12: false });
         this.rateLimitWarning = `GitHub search API quota low (${rateLimit.remaining}/${rateLimit.limit} remaining, resets at ${resetTime}). Search may be slow.`;
-        warn(MODULE10, this.rateLimitWarning);
+        warn(MODULE11, this.rateLimitWarning);
       }
       if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
-        info(MODULE10, `Search budget critical (${searchBudget} remaining) \u2014 running only Phase 0`);
+        info(MODULE11, `Search budget critical (${searchBudget} remaining) \u2014 running only Phase 0`);
       } else if (searchBudget < LOW_BUDGET_THRESHOLD) {
-        info(MODULE10, `Search budget low (${searchBudget} remaining) \u2014 skipping heavy phases (2, 3)`);
+        info(MODULE11, `Search budget low (${searchBudget} remaining) \u2014 skipping heavy phases (2, 3)`);
       }
     } catch (error48) {
       if (getHttpStatusCode(error48) === 401)
         throw error48;
       tracker.init(CRITICAL_BUDGET_THRESHOLD, new Date(Date.now() + 6e4).toISOString());
-      warn(MODULE10, "Could not check rate limit \u2014 using conservative budget, skipping heavy phases:", errorMessage(error48));
+      warn(MODULE11, "Could not check rate limit \u2014 using conservative budget, skipping heavy phases:", errorMessage(error48));
     }
     if (searchBudget <= 0) {
       this.rateLimitWarning = "GitHub search API quota exhausted. Try again after the rate limit resets.";
@@ -37939,15 +38287,15 @@ var IssueDiscovery = class {
     const openPRRepos = this.stateReader.getReposWithOpenPRs();
     const starredRepos = this.getStarredRepos();
     const starredRepoSet = new Set(starredRepos);
-    const lowScoringRepos = new Set(this.deriveLowScoringRepos(config2.minRepoScoreThreshold));
+    const lowScoringRepos = new Set(this.deriveLowScoringRepos(config2.minRepoScoreThreshold).map((r) => r.toLowerCase()));
     const isAnyLanguage = languages.some((l) => l.toLowerCase() === "any");
     const langQuery = isAnyLanguage ? "" : languages.map((l) => `language:${l}`).join(" ");
-    const aiBlocklisted = new Set(config2.aiPolicyBlocklist);
+    const aiBlocklisted = new Set(config2.aiPolicyBlocklist.map((r) => r.toLowerCase()));
     if (aiBlocklisted.size > 0) {
-      debug(MODULE10, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
+      debug(MODULE11, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
     }
     const filterIssues = buildIssueFilter({
-      excludedRepos: new Set(config2.excludeRepos),
+      excludedRepos: new Set(config2.excludeRepos.map((r) => r.toLowerCase())),
       excludeOrgs: new Set((config2.excludeOrgs ?? []).map((o) => o.toLowerCase())),
       aiBlocklisted,
       lowScoringRepos,
@@ -37971,67 +38319,47 @@ var IssueDiscovery = class {
       const remaining = maxResults - allCandidates.length;
       if (remaining > 0) {
         const result = await runPhase0(this.octokit, this.vetter, phase0Repos, remaining, filterIssues);
-        allCandidates.push(...result.candidates);
-        phaseErrors["0"] = result.error;
-        if (result.rateLimitHit)
-          rateLimitHitDuringSearch = true;
+        recordPhaseResult("0", result);
       }
       strategiesUsed.push("merged");
     }
     if (allCandidates.length < maxResults && starredRepos.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD && enabledStrategies.has("starred")) {
-      if (interPhaseDelay > 0) {
-        info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
-        await sleep(interPhaseDelay);
-      }
+      await applyInterPhaseDelay();
       const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
       if (reposToSearch.length > 0) {
         const remaining = maxResults - allCandidates.length;
         if (remaining > 0) {
           const result = await runPhase1(this.octokit, this.vetter, reposToSearch, labels, remaining, filterIssues);
-          allCandidates.push(...result.candidates);
-          phaseErrors["1"] = result.error;
-          if (result.rateLimitHit)
-            rateLimitHitDuringSearch = true;
+          recordPhaseResult("1", result);
+          strategiesUsed.push("starred");
         }
       }
-      strategiesUsed.push("starred");
     }
-    const broadDelay = config2.broadPhaseDelayMs ?? 9e4;
-    const skipThreshold = config2.skipBroadWhenSufficientResults ?? 15;
+    const broadDelay = options.broadPhaseDelayMs ?? config2.broadPhaseDelayMs ?? 9e4;
+    const configuredSkipThreshold = config2.skipBroadWhenSufficientResults ?? 8;
+    const skipThreshold = configuredSkipThreshold > 0 ? Math.min(configuredSkipThreshold, maxResults - 1) : 0;
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("broad")) {
       if (skipThreshold > 0 && allCandidates.length >= skipThreshold) {
-        info(MODULE10, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
+        info(MODULE11, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
       } else {
-        if (interPhaseDelay > 0) {
-          info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
-          await sleep(interPhaseDelay);
-        }
+        await applyInterPhaseDelay();
         if (allCandidates.length > 0 && broadDelay > 0) {
-          info(MODULE10, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
+          info(MODULE11, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
           await sleep(broadDelay);
         } else if (allCandidates.length === 0) {
-          info(MODULE10, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
+          info(MODULE11, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
         }
         const remaining = maxResults - allCandidates.length;
-        const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config2.labels, languages, isAnyLanguage, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
-        allCandidates.push(...result.candidates);
-        phaseErrors["2"] = result.error;
-        if (result.rateLimitHit)
-          rateLimitHitDuringSearch = true;
+        const result = await runPhase2(this.octokit, this.vetter, scopes, labels, config2.labels, languages, isAnyLanguage, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues, tracker);
+        recordPhaseResult("2", result);
+        strategiesUsed.push("broad");
       }
-      strategiesUsed.push("broad");
     }
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("maintained")) {
-      if (interPhaseDelay > 0) {
-        info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
-        await sleep(interPhaseDelay);
-      }
+      await applyInterPhaseDelay();
       const remaining = maxResults - allCandidates.length;
-      const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config2.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, starredRepos, allCandidates, filterIssues);
-      allCandidates.push(...result.candidates);
-      phaseErrors["3"] = result.error;
-      if (result.rateLimitHit)
-        rateLimitHitDuringSearch = true;
+      const result = await runPhase3(this.octokit, this.vetter, langQuery, minStars, config2.projectCategories ?? [], remaining, phase0RepoSet, starredRepoSet, starredRepos, allCandidates, filterIssues, tracker);
+      recordPhaseResult("3", result);
       strategiesUsed.push("maintained");
     }
     const phasesSkippedForBudget = searchBudget < LOW_BUDGET_THRESHOLD;
@@ -38058,8 +38386,13 @@ var IssueDiscovery = class {
     if (rateLimitHitDuringSearch || phasesSkippedForBudget) {
       this.rateLimitWarning = `Search results may be incomplete: GitHub API rate limits were hit during search.${budgetNote} Found ${allCandidates.length} candidate${allCandidates.length === 1 ? "" : "s"} but some search phases were limited. Try again after the rate limit resets for complete results.`;
     }
-    annotateBoost(allCandidates, options.preferLanguages, options.preferRepos);
-    allCandidates.sort((a, b) => {
+    const ranked = annotateBoost(allCandidates, {
+      preferLanguages: options.preferLanguages,
+      preferRepos: options.preferRepos,
+      avoidRepos: options.avoidRepos,
+      boostIssueTypes: options.boostIssueTypes
+    });
+    ranked.sort((a, b) => {
       const priorityOrder = {
         merged_pr: 0,
         starred: 1,
@@ -38072,14 +38405,14 @@ var IssueDiscovery = class {
       const recDiff = recommendationOrder[a.recommendation] - recommendationOrder[b.recommendation];
       if (recDiff !== 0)
         return recDiff;
-      const boostDiff = (b.boostScore ?? 0) - (a.boostScore ?? 0);
+      const boostDiff = boostScoreOf(b) - boostScoreOf(a);
       if (boostDiff !== 0)
         return boostDiff;
       return b.viabilityScore - a.viabilityScore;
     });
-    const capped = applyPerRepoCap(allCandidates, 2);
+    const capped = applyPerRepoCap(ranked, 2);
     const finalPicks = applyDiversityRatio(capped, maxResults, options.diversityRatio ?? 0);
-    info(MODULE10, `Search complete: ${tracker.getTotalCalls()} Search API calls used, ${finalPicks.length} candidates returned`);
+    info(MODULE11, `Search complete: ${tracker.getTotalCalls()} Search API calls used, ${finalPicks.length} candidates returned`);
     return { candidates: finalPicks, strategiesUsed };
   }
   /**
@@ -38112,7 +38445,6 @@ var IssueDiscovery = class {
 };
 
 // ../core/dist/core/roadmap.js
-var MODULE11 = "roadmap";
 var CACHE_TTL_MS2 = 60 * 60 * 1e3;
 var ROADMAP_PATHS = [
   "ROADMAP.md",
@@ -38166,24 +38498,27 @@ async function fetchRoadmapIssueRefs(octokit, owner, repo) {
   if (cached2 && Date.now() - cached2.fetchedAt < CACHE_TTL_MS2) {
     return cached2.refs;
   }
+  const inflight = roadmapInflight.get(cacheKey);
+  if (inflight)
+    return inflight;
+  const promise2 = fetchRoadmapIssueRefsUncached(octokit, owner, repo, cacheKey);
+  roadmapInflight.set(cacheKey, promise2);
+  try {
+    return await promise2;
+  } finally {
+    roadmapInflight.delete(cacheKey);
+  }
+}
+var roadmapInflight = /* @__PURE__ */ new Map();
+async function fetchRoadmapIssueRefsUncached(octokit, owner, repo, cacheKey) {
   for (const path5 of ROADMAP_PATHS) {
-    try {
-      const { data } = await octokit.repos.getContent({ owner, repo, path: path5 });
-      if (!("content" in data))
-        continue;
-      const content = Buffer.from(data.content, "base64").toString("utf-8");
-      const refs = parseRoadmapIssueRefs(content, owner, repo);
-      roadmapCache.set(cacheKey, { refs, fetchedAt: Date.now() });
-      pruneCache2();
-      return refs;
-    } catch (err) {
-      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-        throw err;
-      const status = getHttpStatusCode(err);
-      if (status === 404)
-        continue;
-      warn(MODULE11, `Unexpected error fetching ${path5} from ${owner}/${repo}: ${errorMessage(err)}`);
-    }
+    const { text } = await probeRepoFile(octokit, owner, repo, path5);
+    if (!text)
+      continue;
+    const refs = parseRoadmapIssueRefs(text, owner, repo);
+    roadmapCache.set(cacheKey, { refs, fetchedAt: Date.now() });
+    pruneCache2();
+    return refs;
   }
   const empty = /* @__PURE__ */ new Set();
   roadmapCache.set(cacheKey, { refs: empty, fetchedAt: Date.now() });
@@ -38284,6 +38619,37 @@ function isFeatureIssue(item) {
     return false;
   return labels.some((l) => FEATURE_LABELS.includes(l));
 }
+async function vetAndClassify(item, vetter, roadmapRefs) {
+  const labels = extractLabels(item);
+  const hasMilestone = !!item.milestone;
+  const reactions = item.reactions?.total_count ?? 0;
+  const comments = item.comments ?? 0;
+  const wontfixNoContributor = item.created_at ? detectWontfixNoContributor({ labels, createdAt: item.created_at }) : false;
+  const useRoadmap = roadmapRefs !== void 0;
+  const onRoadmap = useRoadmap && typeof item.number === "number" && roadmapRefs.has(item.number);
+  let candidate;
+  try {
+    candidate = await vetter.vetIssue(item.html_url, {
+      featureSignals: {
+        reactions,
+        comments,
+        hasMilestone,
+        wontfixNoContributor,
+        ...useRoadmap ? { onRoadmap } : {}
+      }
+    });
+  } catch (err) {
+    rethrowIfFatal(err);
+    warn(MODULE12, `vet failed for ${item.html_url}: ${errorMessage(err)}`);
+    return null;
+  }
+  const horizon = classifyHorizon({
+    hasMilestone,
+    labels,
+    ...useRoadmap ? { isOnRoadmap: onRoadmap } : {}
+  });
+  return { ...candidate, horizon };
+}
 async function discoverFeatures(opts) {
   const anchorRepos = resolveAnchorRepos(opts.repoScores, opts.anchorThreshold);
   if (anchorRepos.length === 0) {
@@ -38316,42 +38682,15 @@ async function discoverFeatures(opts) {
       response = listResp;
       roadmapRefs = refs;
     } catch (err) {
-      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-        throw err;
+      rethrowIfFatal(err);
       warn(MODULE12, `failed to list issues for ${anchorRepos[i]}: ${errorMessage(err)}`);
       continue;
     }
     const items = response.data.filter((it) => !it.pull_request && !it.assignee && isFeatureIssue(it));
     for (const item of items) {
-      const labels = extractLabels(item);
-      const hasMilestone = !!item.milestone;
-      const reactions = item.reactions?.total_count ?? 0;
-      const comments = item.comments ?? 0;
-      const wontfixNoContributor = item.created_at ? detectWontfixNoContributor({ labels, createdAt: item.created_at }) : false;
-      const onRoadmap = typeof item.number === "number" && roadmapRefs.has(item.number);
-      let candidate;
-      try {
-        candidate = await opts.vetter.vetIssue(item.html_url, {
-          featureSignals: {
-            reactions,
-            comments,
-            hasMilestone,
-            wontfixNoContributor,
-            onRoadmap
-          }
-        });
-      } catch (err) {
-        if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-          throw err;
-        warn(MODULE12, `vet failed for ${item.html_url}: ${errorMessage(err)}`);
-        continue;
-      }
-      const horizon = classifyHorizon({
-        hasMilestone,
-        labels,
-        isOnRoadmap: onRoadmap
-      });
-      candidates.push({ ...candidate, horizon });
+      const candidate = await vetAndClassify(item, opts.vetter, roadmapRefs);
+      if (candidate)
+        candidates.push(candidate);
     }
   }
   const passing = candidates.filter((c) => c.viabilityScore >= MIN_VIABILITY_SCORE);
@@ -38372,10 +38711,8 @@ function buildBroadFeatureSearchQuery(opts) {
   for (const excl of FEATURE_EXCLUSION_LABELS) {
     parts.push(`-label:"${excl}"`);
   }
-  const languages = (opts.languages ?? []).filter((l) => l && l.toLowerCase() !== "any");
-  if (languages.length > 0) {
-    const langClause = languages.map((l) => `language:${l}`).join(" OR ");
-    parts.push(`(${langClause})`);
+  if (opts.language) {
+    parts.push(`language:${opts.language}`);
   }
   for (const repo of opts.excludeRepos ?? []) {
     parts.push(`-repo:${repo}`);
@@ -38385,8 +38722,19 @@ function buildBroadFeatureSearchQuery(opts) {
   }
   return parts.join(" ");
 }
+function buildBroadFeatureSearchQueries(opts) {
+  const base = {
+    excludeRepos: opts.excludeRepos,
+    excludeOrgs: opts.excludeOrgs
+  };
+  const languages = (opts.languages ?? []).filter((l) => l && l.toLowerCase() !== "any");
+  if (languages.length === 0) {
+    return [buildBroadFeatureSearchQuery(base)];
+  }
+  return languages.map((language) => buildBroadFeatureSearchQuery({ ...base, language }));
+}
 async function discoverFeaturesBroad(opts) {
-  const query = buildBroadFeatureSearchQuery({
+  const queries = buildBroadFeatureSearchQueries({
     languages: opts.languages,
     excludeRepos: opts.excludeRepos,
     excludeOrgs: opts.excludeOrgs
@@ -38394,16 +38742,25 @@ async function discoverFeaturesBroad(opts) {
   const maxToVet = opts.maxToVet ?? DEFAULT_BROAD_MAX_TO_VET;
   let items;
   try {
-    const response = await opts.octokit.search.issuesAndPullRequests({
-      q: query,
-      sort: "interactions",
-      order: "desc",
-      per_page: maxToVet
-    });
-    items = response.data.items.filter((it) => !it.pull_request && !it.assignee && isFeatureIssue(it));
+    const merged = [];
+    const seenUrls = /* @__PURE__ */ new Set();
+    for (const query of queries) {
+      const data = await cachedSearchIssues(opts.octokit, {
+        q: query,
+        sort: "interactions",
+        order: "desc",
+        per_page: maxToVet
+      });
+      for (const raw of data.items) {
+        if (seenUrls.has(raw.html_url))
+          continue;
+        seenUrls.add(raw.html_url);
+        merged.push(raw);
+      }
+    }
+    items = merged.filter((it) => !it.pull_request && !it.assignee && isFeatureIssue(it)).slice(0, maxToVet);
   } catch (err) {
-    if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-      throw err;
+    rethrowIfFatal(err);
     warn(MODULE12, `broad feature search failed: ${errorMessage(err)}`);
     return {
       quickWins: [],
@@ -38414,32 +38771,9 @@ async function discoverFeaturesBroad(opts) {
   }
   const candidates = [];
   for (const item of items) {
-    const labels = extractLabels(item);
-    const hasMilestone = !!item.milestone;
-    const reactions = item.reactions?.total_count ?? 0;
-    const comments = item.comments ?? 0;
-    const wontfixNoContributor = item.created_at ? detectWontfixNoContributor({ labels, createdAt: item.created_at }) : false;
-    let candidate;
-    try {
-      candidate = await opts.vetter.vetIssue(item.html_url, {
-        featureSignals: {
-          reactions,
-          comments,
-          hasMilestone,
-          wontfixNoContributor
-          // Roadmap scraping is per-repo and would require an extra fetch
-          // per unique repo in the broad result set — deliberately skipped
-          // here to keep the broad path cheap. Anchor mode keeps the bonus.
-        }
-      });
-    } catch (err) {
-      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-        throw err;
-      warn(MODULE12, `vet failed for ${item.html_url}: ${errorMessage(err)}`);
-      continue;
-    }
-    const horizon = classifyHorizon({ hasMilestone, labels });
-    candidates.push({ ...candidate, horizon });
+    const candidate = await vetAndClassify(item, opts.vetter);
+    if (candidate)
+      candidates.push(candidate);
   }
   const passing = candidates.filter((c) => c.viabilityScore >= MIN_VIABILITY_SCORE);
   const split = splitByHorizon(passing, opts.count, opts.splitRatio);
@@ -38459,14 +38793,11 @@ var GIST_DESCRIPTION = "oss-scout-state";
 var GIST_FILENAME = "state.json";
 var GIST_ID_FILE = "gist-id";
 var CACHE_FILE = "state-cache.json";
-var SEARCH_MAX_PAGES = 5;
+var SEARCH_MAX_PAGES = 10;
 function classifyDegradedReason(err) {
   if (isRateLimitError(err))
     return "rate_limit";
   const status = getHttpStatusCode(err);
-  if (status === 403 && errorMessage(err).toLowerCase().includes("abuse detection")) {
-    return "rate_limit";
-  }
   if (status !== void 0 && status >= 500 && status < 600)
     return "server";
   if (err && typeof err === "object" && "code" in err) {
@@ -38510,12 +38841,23 @@ var GistStateStore = class {
    * Push state to the gist. Also writes to local cache as fallback.
    */
   async push(state) {
-    this.writeCache(state);
     if (!this.gistId) {
       warn(MODULE13, "No gist ID \u2014 cannot push");
+      this.writeCache(state);
       return false;
     }
-    const json2 = JSON.stringify(state, null, 2);
+    let toWrite = state;
+    try {
+      const remote = await this.fetchGistState(this.gistId);
+      if (remote) {
+        toWrite = mergeStates(state, remote);
+      }
+    } catch (err) {
+      rethrowIfFatal(err);
+      warn(MODULE13, `Could not fetch gist before push, writing local snapshot: ${errorMessage(err)}`);
+    }
+    this.writeCache(toWrite);
+    const json2 = JSON.stringify(toWrite, null, 2);
     if (json2.length > 9e5) {
       warn(MODULE13, `State too large for gist (${Math.round(json2.length / 1024)}KB). Consider clearing old results with 'oss-scout results clear'.`);
       return false;
@@ -38530,31 +38872,11 @@ var GistStateStore = class {
       debug(MODULE13, "State pushed to gist");
       return true;
     } catch (err) {
-      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-        throw err;
+      rethrowIfFatal(err);
       warn(MODULE13, `Failed to push: ${errorMessage(err)}`);
       return false;
     }
   }
-  /**
-   * Pull state from the gist and merge with local state.
-   */
-  async pull() {
-    if (!this.gistId)
-      return null;
-    try {
-      const state = await this.fetchGistState(this.gistId);
-      if (state) {
-        this.writeCache(state);
-      }
-      return state;
-    } catch (err) {
-      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
-        throw err;
-      warn(MODULE13, `Failed to pull: ${errorMessage(err)}`);
-      return null;
-    }
-  }
   /** Get the current gist ID (if known). */
   getGistId() {
     return this.gistId;
@@ -38565,9 +38887,10 @@ var GistStateStore = class {
     if (cachedId) {
       debug(MODULE13, `Trying cached gist ID: ${cachedId}`);
       try {
-        const state = await this.fetchGistState(cachedId);
-        if (state) {
+        const fetched = await this.fetchGistState(cachedId);
+        if (fetched) {
           this.gistId = cachedId;
+          const state = this.mergeCacheInto(fetched);
           this.writeCache(state);
           return { gistId: cachedId, state, created: false };
         }
@@ -38578,19 +38901,23 @@ var GistStateStore = class {
       }
       debug(MODULE13, "Cached gist ID invalid, searching...");
     }
-    const foundId = await this.searchForGist();
-    if (foundId) {
-      debug(MODULE13, `Found gist via search: ${foundId}`);
-      this.saveGistId(foundId);
-      this.gistId = foundId;
-      const state = await this.fetchGistState(foundId);
-      if (state) {
+    const search = await this.searchForGist();
+    if (search.id) {
+      debug(MODULE13, `Found gist via search: ${search.id}`);
+      this.saveGistId(search.id);
+      this.gistId = search.id;
+      const fetched = await this.fetchGistState(search.id);
+      if (fetched) {
+        const state = this.mergeCacheInto(fetched);
         this.writeCache(state);
-        return { gistId: foundId, state, created: false };
+        return { gistId: search.id, state, created: false };
       }
-      warn(MODULE13, `Found existing gist ${foundId} but content failed validation. Using local cache to avoid data loss.`);
+      warn(MODULE13, `Found existing gist ${search.id} but content failed validation. Using local cache to avoid data loss.`);
       return this.bootstrapFromCache("unknown");
     }
+    if (!search.exhaustive) {
+      warn(MODULE13, `Scanned the first ${SEARCH_MAX_PAGES * 100} gists without finding an oss-scout state gist, but the account has more. Creating a new state gist; if one already exists, copy its id into the gist-id file in the oss-scout data directory to avoid a duplicate.`);
+    }
     debug(MODULE13, "No existing gist found, creating new one");
     const freshState = ScoutStateSchema.parse({ version: 1 });
     const newId = await this.createGist(freshState);
@@ -38632,12 +38959,17 @@ var GistStateStore = class {
       return null;
     try {
       const parsed = JSON.parse(file2.content);
-      return ScoutStateSchema.parse(parsed);
+      return parseScoutState(parsed);
     } catch (err) {
       warn(MODULE13, `Gist content failed validation: ${errorMessage(err)}`);
       return null;
     }
   }
+  /**
+   * Scan the user's gists for the state gist. `exhaustive: false` means the
+   * page cap was hit while pages were still full, so the account may hold
+   * the state gist beyond the scan window.
+   */
   async searchForGist() {
     for (let page = 1; page <= SEARCH_MAX_PAGES; page++) {
       const { data: gists } = await this.octokit.gists.list({
@@ -38645,12 +38977,14 @@ var GistStateStore = class {
         page
       });
       if (gists.length === 0)
-        break;
+        return { id: null, exhaustive: true };
       const match = gists.find((g) => g.description === GIST_DESCRIPTION);
       if (match)
-        return match.id;
+        return { id: match.id, exhaustive: true };
+      if (gists.length < 100)
+        return { id: null, exhaustive: true };
     }
-    return null;
+    return { id: null, exhaustive: false };
   }
   async createGist(state) {
     const { data } = await this.octokit.gists.create({
@@ -38678,10 +39012,21 @@ var GistStateStore = class {
   saveGistId(id) {
     fs3.writeFileSync(getGistIdPath(), id + "\n", { mode: 384 });
   }
+  /**
+   * Merge the local state-cache into a freshly fetched gist state before it
+   * overwrites the cache (#117). Without this, a prior failed push left its
+   * only copy of the user's changes in state-cache.json, which the next
+   * successful bootstrap silently clobbered. Tombstone-aware mergeStates
+   * keeps both sides' real changes.
+   */
+  mergeCacheInto(fetched) {
+    const cached2 = this.readCache();
+    return cached2 ? mergeStates(cached2, fetched) : fetched;
+  }
   readCache() {
     try {
       const raw = fs3.readFileSync(getCachePath(), "utf-8");
-      return ScoutStateSchema.parse(JSON.parse(raw));
+      return parseScoutState(JSON.parse(raw));
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") {
@@ -38700,18 +39045,57 @@ var GistStateStore = class {
     }
   }
 };
+var TOMBSTONE_TTL_MS = 90 * 24 * 60 * 60 * 1e3;
+function mergeTombstones(local, remote) {
+  const cutoff = Date.now() - TOMBSTONE_TTL_MS;
+  const byUrl = /* @__PURE__ */ new Map();
+  for (const t of [...local, ...remote]) {
+    const existing = byUrl.get(t.url);
+    if (!existing || t.removedAt > existing.removedAt)
+      byUrl.set(t.url, t);
+  }
+  return [...byUrl.values()].filter((t) => {
+    const ts = new Date(t.removedAt).getTime();
+    return !Number.isFinite(ts) || ts >= cutoff;
+  });
+}
+function applyTombstones(items, tombstones, urlOf, touchedAtOf) {
+  if (tombstones.length === 0)
+    return items;
+  const byUrl = new Map(tombstones.map((t) => [t.url, t.removedAt]));
+  return items.filter((item) => {
+    const removedAt = byUrl.get(urlOf(item));
+    if (removedAt === void 0)
+      return true;
+    return touchedAtOf(item) > removedAt;
+  });
+}
 function mergeStates(local, remote) {
+  const tombstones = mergeTombstones(local.tombstones ?? [], remote.tombstones ?? []);
+  const savedResults = applyTombstones(mergeSavedResults(local.savedResults ?? [], remote.savedResults ?? []), tombstones, (r) => r.issueUrl, (r) => r.lastSeenAt);
+  const skippedIssues = applyTombstones(mergeSkippedIssues(local.skippedIssues ?? [], remote.skippedIssues ?? []), tombstones, (s) => s.url, (s) => s.skippedAt);
+  const skippedUrls = new Set(skippedIssues.map((s) => s.url));
+  const savedResultsFinal = savedResults.filter((r) => !skippedUrls.has(r.issueUrl));
+  const localPrefsTs = local.preferencesUpdatedAt;
+  const remotePrefsTs = remote.preferencesUpdatedAt;
+  const localPrefsWin = localPrefsTs !== void 0 && (remotePrefsTs === void 0 || localPrefsTs > remotePrefsTs);
+  const preferences = localPrefsWin ? local.preferences : remote.preferences;
+  const preferencesUpdatedAt = pickFresherTimestamp(localPrefsTs, remotePrefsTs);
   return {
+    ...local,
+    ...remote,
     version: 1,
-    preferences: remote.preferences,
+    preferences,
+    preferencesUpdatedAt,
+    tombstones,
     repoScores: mergeRepoScores(local.repoScores, remote.repoScores),
     starredRepos: mergeStarredRepos(local, remote),
     starredReposLastFetched: pickFresherTimestamp(local.starredReposLastFetched, remote.starredReposLastFetched),
     mergedPRs: unionByUrl(local.mergedPRs, remote.mergedPRs),
     closedPRs: unionByUrl(local.closedPRs, remote.closedPRs),
     openPRs: unionByUrl(local.openPRs ?? [], remote.openPRs ?? []),
-    savedResults: mergeSavedResults(local.savedResults ?? [], remote.savedResults ?? []),
-    skippedIssues: mergeSkippedIssues(local.skippedIssues ?? [], remote.skippedIssues ?? []),
+    savedResults: savedResultsFinal,
+    skippedIssues,
     lastSearchAt: pickFresherTimestamp(local.lastSearchAt, remote.lastSearchAt),
     lastRunAt: pickFresherTimestamp(local.lastRunAt, remote.lastRunAt) ?? (/* @__PURE__ */ new Date()).toISOString(),
     gistId: remote.gistId ?? local.gistId
@@ -38793,7 +39177,7 @@ function loadLocalState() {
   const statePath = getStatePath();
   try {
     const raw = fs4.readFileSync(statePath, "utf-8");
-    return ScoutStateSchema.parse(JSON.parse(raw));
+    return parseScoutState(JSON.parse(raw));
   } catch (err) {
     const code = err?.code;
     if (code === "ENOENT") {
@@ -38810,6 +39194,23 @@ function loadLocalState() {
     return ScoutStateSchema.parse({ version: 1 });
   }
 }
+var tmpCounter = 0;
+function saveLocalState(state) {
+  const statePath = getStatePath();
+  const tmpPath = `${statePath}.tmp.${process.pid}.${tmpCounter++}`;
+  const data = JSON.stringify(state, null, 2) + "\n";
+  fs4.writeFileSync(tmpPath, data, { mode: 384 });
+  try {
+    fs4.renameSync(tmpPath, statePath);
+  } catch (err) {
+    try {
+      fs4.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+  debug(MODULE14, "State saved");
+}
 
 // ../core/dist/scout.js
 function offlineModeMessage(reason) {
@@ -38864,8 +39265,12 @@ function toGistOctokit(octokit) {
   };
 }
 async function createScout(config2) {
+  if (config2.logLevel !== void 0) {
+    setLogLevel(config2.logLevel);
+  }
   let state;
   let gistStore = null;
+  let persistLocal = false;
   if (config2.persistence === "provided") {
     state = config2.initialState;
   } else if (config2.persistence === "gist") {
@@ -38882,37 +39287,67 @@ async function createScout(config2) {
       state.gistId = result.gistId;
     }
   } else {
-    state = ScoutStateSchema.parse({ version: 1 });
+    state = loadLocalState();
+    persistLocal = true;
   }
-  return new OssScout(config2.githubToken, state, gistStore);
+  return new OssScout(config2.githubToken, state, gistStore, { persistLocal });
 }
 var OssScout = class {
   githubToken;
   gistStore;
   state;
   dirty = false;
-  constructor(githubToken, initialState, gistStore = null) {
+  /** When true, checkpoint() also writes ~/.oss-scout/state.json. */
+  persistLocal;
+  constructor(githubToken, initialState, gistStore = null, opts = {}) {
     this.githubToken = githubToken;
     this.gistStore = gistStore;
     this.state = initialState;
+    this.persistLocal = opts.persistLocal ?? false;
   }
   // ── Search ──────────────────────────────────────────────────────────
+  /**
+   * 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).
+   */
+  evictStaleCacheEntries() {
+    getHttpCache().evictStale();
+  }
   /**
    * Multi-strategy issue search. Returns scored, sorted candidates.
    * Automatically culls expired skip entries and filters skipped issues.
    */
   async search(options) {
+    this.evictStaleCacheEntries();
     this.cullExpiredSkips();
     const skippedUrls = new Set((this.state.skippedIssues ?? []).map((s) => s.url));
     const discovery = new IssueDiscovery(this.githubToken, this.state.preferences, this);
+    const prefs = this.state.preferences;
+    const prefLangs = prefs.preferLanguages ?? [];
+    const prefRepos = prefs.preferRepos ?? [];
+    const preferLanguages = options?.preferLanguages ?? (prefLangs.length > 0 ? prefLangs : void 0);
+    const preferRepos = options?.preferRepos ?? (prefRepos.length > 0 ? prefRepos : void 0);
+    const prefAvoid = prefs.avoidRepos ?? [];
+    const prefBoostTypes = prefs.boostIssueTypes ?? [];
+    const avoidRepos = options?.avoidRepos ?? (prefAvoid.length > 0 ? prefAvoid : void 0);
+    const boostIssueTypes = options?.boostIssueTypes ?? (prefBoostTypes.length > 0 ? prefBoostTypes : void 0);
+    const diversityRatio = options?.diversityRatio ?? prefs.diversityRatio ?? 0;
     const { candidates, strategiesUsed } = await discovery.searchIssues({
       maxResults: options?.maxResults,
       strategies: options?.strategies,
       skippedUrls,
-      preferLanguages: options?.preferLanguages,
-      preferRepos: options?.preferRepos,
-      diversityRatio: options?.diversityRatio
+      preferLanguages,
+      preferRepos,
+      avoidRepos,
+      boostIssueTypes,
+      diversityRatio,
+      interPhaseDelayMs: options?.interPhaseDelayMs,
+      broadPhaseDelayMs: options?.broadPhaseDelayMs
     });
+    for (const c of candidates) {
+      this.updateRepoSignalsFromHealth(c.projectHealth);
+    }
     this.state.lastSearchAt = (/* @__PURE__ */ new Date()).toISOString();
     this.dirty = true;
     return {
@@ -38923,6 +39358,27 @@ var OssScout = class {
       strategiesUsed
     };
   }
+  /**
+   * 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.
+   */
+  updateRepoSignalsFromHealth(health) {
+    if (health.checkFailed)
+      return;
+    this.updateRepoScore(health.repo, {
+      signals: { hasActiveMaintainers: health.isActive }
+    });
+  }
   /**
    * Vet a single issue URL for claimability.
    */
@@ -38945,6 +39401,7 @@ var OssScout = class {
    * preferences and excluded repos/orgs.
    */
   async features(options) {
+    this.evictStaleCacheEntries();
     const count = options?.count ?? 10;
     const octokit = getOctokit(this.githubToken);
     const vetter = new IssueVetter(octokit, this);
@@ -38976,6 +39433,7 @@ var OssScout = class {
    * Optionally prunes unavailable issues from saved results.
    */
   async vetList(options) {
+    this.evictStaleCacheEntries();
     const saved = this.getSavedResults();
     const concurrency = options?.concurrency ?? 5;
     const results = [];
@@ -38991,6 +39449,7 @@ var OssScout = class {
           number: item.number,
           title: item.title,
           status: this.classifyVetResult(candidate),
+          ok: true,
           recommendation: candidate.recommendation,
           viabilityScore: candidate.viabilityScore
         });
@@ -39007,6 +39466,7 @@ var OssScout = class {
           number: item.number,
           title: item.title,
           status: isGone ? "closed" : "error",
+          ok: false,
           errorMessage: errorMessage(error48)
         });
       }).finally(() => {
@@ -39032,17 +39492,41 @@ var OssScout = class {
       hasPR: results.filter((r) => r.status === "has_pr").length,
       errors: results.filter((r) => r.status === "error").length
     };
+    const prevStatus = new Map((this.state.savedResults ?? []).map((r) => [r.issueUrl, r.lastStatus]));
+    const transitions = results.filter((r) => r.status !== "error").filter((r) => {
+      const prev = prevStatus.get(r.issueUrl);
+      return prev !== void 0 && prev !== r.status;
+    }).map((r) => ({
+      issueUrl: r.issueUrl,
+      repo: r.repo,
+      number: r.number,
+      from: prevStatus.get(r.issueUrl),
+      to: r.status
+    }));
+    const currentStatus = new Map(results.map((r) => [r.issueUrl, r.status]));
+    for (const saved2 of this.state.savedResults ?? []) {
+      const status = currentStatus.get(saved2.issueUrl);
+      if (status !== void 0 && status !== "error") {
+        saved2.lastStatus = status;
+      }
+    }
+    if (results.length > 0)
+      this.dirty = true;
     let prunedCount;
     if (options?.prune) {
       const unavailableUrls = new Set(results.filter((r) => r.status !== "still_available").map((r) => r.issueUrl));
       const before = (this.state.savedResults ?? []).length;
       this.state.savedResults = (this.state.savedResults ?? []).filter((r) => !unavailableUrls.has(r.issueUrl));
       prunedCount = before - (this.state.savedResults?.length ?? 0);
+      if (prunedCount > 0)
+        this.addTombstones([...unavailableUrls]);
       this.dirty = true;
     }
-    return { results, summary, prunedCount };
+    return { results, summary, prunedCount, transitions };
   }
   classifyVetResult(candidate) {
+    if (candidate.issueState === "closed")
+      return "closed";
     const checks = candidate.vettingResult.checks;
     if (!checks.noExistingPR)
       return "has_pr";
@@ -39077,19 +39561,35 @@ var OssScout = class {
   getProjectCategories() {
     return this.state.preferences.projectCategories;
   }
+  /** Configured GitHub username (used to classify own vs competing PRs, #166). */
+  getGitHubUsername() {
+    return this.state.preferences.githubUsername;
+  }
   getRepoScore(repo) {
     const score = this.state.repoScores[repo];
     return score ? score.score : 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.
+   */
+  getClosedWithoutMergeCount(repo) {
+    const score = this.state.repoScores[repo];
+    if (score)
+      return score.closedWithoutMergeCount;
+    return (this.state.closedPRs ?? []).filter((p) => extractRepoFromUrl(p.url) === repo).length;
+  }
+  /**
+   * 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() {
-    return {
-      model: this.state.preferences.slmTriageModel ?? "",
-      host: this.state.preferences.slmTriageHost ?? ""
-    };
+    const model = this.state.preferences.slmTriageModel ?? "";
+    if (!model)
+      return null;
+    return { model, host: this.state.preferences.slmTriageHost ?? "" };
   }
   /** Get current preferences (read-only). */
   getPreferences() {
@@ -39143,6 +39643,73 @@ var OssScout = class {
     ];
     this.dirty = true;
   }
+  /**
+   * 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.
+   */
+  async syncOpenPRs() {
+    const octokit = getOctokit(this.githubToken);
+    const open = this.state.openPRs ?? [];
+    const result = {
+      checked: open.length,
+      merged: 0,
+      closed: 0,
+      stillOpen: 0,
+      errors: 0
+    };
+    const remaining = [];
+    for (const pr of open) {
+      const parsed = parseGitHubUrl(pr.url);
+      if (!parsed || parsed.type !== "pull") {
+        remaining.push(pr);
+        result.errors++;
+        continue;
+      }
+      const repoFullName = `${parsed.owner}/${parsed.repo}`;
+      try {
+        const { data } = await octokit.pulls.get({
+          owner: parsed.owner,
+          repo: parsed.repo,
+          pull_number: parsed.number
+        });
+        if (data.merged) {
+          this.recordMergedPR({
+            url: pr.url,
+            title: pr.title,
+            mergedAt: data.merged_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+            repo: repoFullName
+          });
+          result.merged++;
+        } else if (data.state === "closed") {
+          this.recordClosedPR({
+            url: pr.url,
+            title: pr.title,
+            closedAt: data.closed_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+            repo: repoFullName
+          });
+          result.closed++;
+        } else {
+          remaining.push(pr);
+          result.stillOpen++;
+        }
+      } catch (err) {
+        rethrowIfFatal(err);
+        warn("scout", `sync: could not check ${pr.url}: ${errorMessage(err)}`);
+        remaining.push(pr);
+        result.errors++;
+      }
+    }
+    this.state.openPRs = remaining;
+    this.dirty = true;
+    await this.checkpoint();
+    return result;
+  }
   /**
    * Update repo score with observed signals.
    */
@@ -39177,6 +39744,7 @@ var OssScout = class {
    */
   updatePreferences(updates) {
     this.state.preferences = { ...this.state.preferences, ...updates };
+    this.state.preferencesUpdatedAt = (/* @__PURE__ */ new Date()).toISOString();
     this.dirty = true;
   }
   /**
@@ -39226,9 +39794,25 @@ var OssScout = class {
    * Clear all saved results.
    */
   clearResults() {
+    this.addTombstones((this.state.savedResults ?? []).map((r) => r.issueUrl));
     this.state.savedResults = [];
     this.dirty = true;
   }
+  /**
+   * 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.
+   */
+  addTombstones(urls) {
+    if (urls.length === 0)
+      return;
+    const removedAt = (/* @__PURE__ */ new Date()).toISOString();
+    const existing = this.state.tombstones ?? [];
+    const byUrl = new Map(existing.map((t) => [t.url, t]));
+    for (const url2 of urls)
+      byUrl.set(url2, { url: url2, removedAt });
+    this.state.tombstones = [...byUrl.values()];
+  }
   // ── Skip List ───────────────────────────────────────────────────────
   /**
    * Skip an issue — excludes it from future searches. Auto-culled after 90 days.
@@ -39262,13 +39846,17 @@ var OssScout = class {
    * Remove a specific issue from the skip list.
    */
   unskipIssue(url2) {
+    const before = (this.state.skippedIssues ?? []).length;
     this.state.skippedIssues = (this.state.skippedIssues ?? []).filter((s) => s.url !== url2);
+    if (this.state.skippedIssues.length < before)
+      this.addTombstones([url2]);
     this.dirty = true;
   }
   /**
    * Clear all skipped issues.
    */
   clearSkippedIssues() {
+    this.addTombstones((this.state.skippedIssues ?? []).map((s) => s.url));
     this.state.skippedIssues = [];
     this.dirty = true;
   }
@@ -39312,6 +39900,13 @@ var OssScout = class {
       if (!ok)
         return false;
     }
+    if (this.persistLocal) {
+      try {
+        saveLocalState(this.state);
+      } catch {
+        return false;
+      }
+    }
     this.dirty = false;
     return true;
   }
@@ -39332,16 +39927,21 @@ var OssScout = class {
     });
   }
   /**
-   * 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.
    */
   calculateScore(repoScore) {
     let score = 5;
     score += Math.min(repoScore.mergedPRCount, 3);
     score -= Math.min(repoScore.closedWithoutMergeCount, 3);
-    if (repoScore.signals.isResponsive)
-      score += 1;
     if (repoScore.signals.hasActiveMaintainers)
       score += 1;
     if (repoScore.signals.hasHostileComments)
@@ -39350,8 +39950,158 @@ var OssScout = class {
   }
 };
 
+// ../core/dist/core/preference-fields.js
+var FIELD_CONFIGS = {
+  githubUsername: { type: "string" },
+  languages: { type: "array" },
+  labels: { type: "array" },
+  scope: { type: "enum-array", validValues: IssueScopeSchema.options },
+  excludeRepos: { type: "array" },
+  excludeOrgs: { type: "array" },
+  aiPolicyBlocklist: { type: "array" },
+  projectCategories: {
+    type: "enum-array",
+    validValues: ProjectCategorySchema.options
+  },
+  minStars: { type: "number" },
+  maxIssueAgeDays: { type: "number" },
+  includeDocIssues: { type: "boolean" },
+  minRepoScoreThreshold: { type: "number" },
+  interPhaseDelayMs: { type: "number" },
+  persistence: { type: "enum", validValues: PersistenceModeSchema.options },
+  defaultStrategy: {
+    type: "enum-array",
+    validValues: SearchStrategySchema.options
+  },
+  broadPhaseDelayMs: { type: "number" },
+  skipBroadWhenSufficientResults: { type: "number" },
+  preferLanguages: { type: "array" },
+  preferRepos: { type: "array" },
+  diversityRatio: { type: "float" },
+  avoidRepos: { type: "array" },
+  boostIssueTypes: { type: "array" },
+  slmTriageModel: { type: "string" },
+  slmTriageHost: { type: "string" },
+  featuresAnchorThreshold: { type: "number" },
+  featuresSplitRatio: { type: "float" }
+};
+var PREFERENCE_KEYS = Object.keys(ScoutPreferencesSchema.shape);
+var SORTED_PREFERENCE_KEYS = [
+  ...PREFERENCE_KEYS
+].sort();
+function parseBoolean(value) {
+  const lower = value.toLowerCase();
+  if (lower === "true" || lower === "yes")
+    return true;
+  if (lower === "false" || lower === "no")
+    return false;
+  throw new ValidationError(`Invalid boolean value: "${value}". Use true/false or yes/no.`);
+}
+function parseIntValue(value, key) {
+  const num = parseInt(value, 10);
+  if (isNaN(num)) {
+    throw new ValidationError(`Invalid number for "${key}": "${value}"`);
+  }
+  return num;
+}
+function parseFloatValue(value, key) {
+  const num = Number.parseFloat(value);
+  if (isNaN(num)) {
+    throw new ValidationError(`Invalid number for "${key}": "${value}"`);
+  }
+  return num;
+}
+function parseArrayValue(value) {
+  return value.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+}
+function updateArray(current, value) {
+  if (value.startsWith("+")) {
+    const toAdd = parseArrayValue(value.slice(1));
+    const merged = [...current];
+    for (const item of toAdd) {
+      if (!merged.includes(item))
+        merged.push(item);
+    }
+    return merged;
+  }
+  if (value.startsWith("-")) {
+    const toRemove = new Set(parseArrayValue(value.slice(1)));
+    return current.filter((item) => !toRemove.has(item));
+  }
+  return parseArrayValue(value);
+}
+function applyPreferenceField(preferences, key, value) {
+  const field = FIELD_CONFIGS[key];
+  if (!field) {
+    throw new ValidationError(`Unknown config key: "${key}". Valid keys: ${SORTED_PREFERENCE_KEYS.join(", ")}`);
+  }
+  const prefs = { ...preferences };
+  switch (field.type) {
+    case "string":
+      prefs[key] = value;
+      break;
+    case "boolean":
+      prefs[key] = parseBoolean(value);
+      break;
+    case "number":
+      prefs[key] = parseIntValue(value, key);
+      break;
+    case "float":
+      prefs[key] = parseFloatValue(value, key);
+      break;
+    case "array": {
+      const current = prefs[key] ?? [];
+      prefs[key] = updateArray(current, value);
+      break;
+    }
+    case "enum": {
+      const validValues = field.validValues;
+      if (!validValues.includes(value)) {
+        throw new ValidationError(`Invalid value for "${key}": "${value}". Valid: ${validValues.join(", ")}`);
+      }
+      prefs[key] = value;
+      break;
+    }
+    case "enum-array": {
+      const current = prefs[key] ?? [];
+      const updated = updateArray(current, value);
+      const validValues = field.validValues;
+      const invalid = updated.filter((s) => !validValues.includes(s));
+      if (invalid.length > 0) {
+        throw new ValidationError(`Invalid value(s) for "${key}": ${invalid.join(", ")}. Valid: ${validValues.join(", ")}`);
+      }
+      if (key === "scope") {
+        prefs[key] = updated.length > 0 ? updated : void 0;
+      } else {
+        prefs[key] = updated;
+      }
+      break;
+    }
+  }
+  return ScoutPreferencesSchema.parse(prefs);
+}
+
+// ../core/dist/commands/validation.js
+var ISSUE_URL_PATTERN = /^https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/\d+$/;
+var MAX_URL_LENGTH = 2048;
+function validateGitHubUrl(url2, pattern, entityType) {
+  if (pattern.test(url2))
+    return;
+  throw new ValidationError(`Invalid ${entityType} URL: ${url2}. Expected format: https://github.com/owner/repo/issues/123`);
+}
+function validateUrl(url2) {
+  if (url2.length > MAX_URL_LENGTH) {
+    throw new ValidationError(`URL exceeds maximum length of ${MAX_URL_LENGTH} characters`);
+  }
+  return url2;
+}
+
 // src/tools.ts
-var TOOL_TIMEOUT_MS = 6e4;
+var TOOL_TIMEOUT_MS = 3e5;
+var PERSIST_WARNING = "Checkpoint failed: changes were applied in memory but could not be persisted. They may be lost when the server restarts.";
+function withPersistWarning(payload, persisted) {
+  return persisted ? payload : { ...payload, persistWarning: PERSIST_WARNING };
+}
 function withTimeout(promise2, ms = TOOL_TIMEOUT_MS) {
   let timeoutId;
   const timer = new Promise((_, reject) => {
@@ -39377,6 +40127,12 @@ function registerTools(server, scout) {
       preferRepos: external_exports3.array(external_exports3.string()).optional().describe(
         "Soft-boost ranking for candidates in one of these `owner/repo` slugs. Stronger weight than language match (#1244). Not a filter; only reorders."
       ),
+      avoidRepos: external_exports3.array(external_exports3.string()).optional().describe(
+        "Soft PENALTY (milder than excludeRepos) for candidates in one of these `owner/repo` slugs (#168). Pushes them down the ranking but does not remove them; a strong boost can still outweigh it."
+      ),
+      boostIssueTypes: external_exports3.array(external_exports3.string()).optional().describe(
+        'Soft-boost ranking for candidates whose issue labels match one of these types, case-insensitive (e.g. "bug", "good first issue") (#168). Not a filter; only reorders.'
+      ),
       diversityRatio: external_exports3.number().min(0).max(1).optional().describe(
         "Diversity counterweight (#1244): fraction of result slots reserved for candidates that matched NEITHER preference list. Counters echo-chamber bias when boosts accumulate over time. 0 disables, 1 reserves every slot for diversity. Default 0."
       )
@@ -39386,6 +40142,8 @@ function registerTools(server, scout) {
       strategies,
       preferLanguages,
       preferRepos,
+      avoidRepos,
+      boostIssueTypes,
       diversityRatio
     }) => {
       try {
@@ -39396,13 +40154,28 @@ function registerTools(server, scout) {
             strategies: parsedStrategies,
             preferLanguages,
             preferRepos,
-            diversityRatio
+            avoidRepos,
+            boostIssueTypes,
+            diversityRatio,
+            // No fixed inter-phase sleeps in the request/response MCP context;
+            // the budget tracker still paces the GitHub calls (#143)
+            interPhaseDelayMs: 0,
+            broadPhaseDelayMs: 0
           })
         );
         scout.saveResults(result.candidates);
-        await scout.checkpoint();
+        const persisted = await scout.checkpoint();
         return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                withPersistWarning(result, persisted),
+                null,
+                2
+              )
+            }
+          ]
         };
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -39431,9 +40204,18 @@ function registerTools(server, scout) {
           })
         );
         scout.saveResults([...result.quickWins, ...result.biggerBets]);
-        await scout.checkpoint();
+        const persisted = await scout.checkpoint();
         return {
-          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(
+                withPersistWarning(result, persisted),
+                null,
+                2
+              )
+            }
+          ]
         };
       } catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -39477,6 +40259,24 @@ function registerTools(server, scout) {
       };
     }
   );
+  server.tool(
+    "sync",
+    "Reconcile tracked open PRs against GitHub \u2014 mark merged/closed and recompute repo scores. Cheap; good for a daily startup call.",
+    async () => {
+      try {
+        const result = await withTimeout(scout.syncOpenPRs());
+        return {
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+        };
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: `Error: ${msg}` }],
+          isError: true
+        };
+      }
+    }
+  );
   server.tool(
     "skip",
     "Skip, unskip, list, or clear skipped issues. Skipped issues are excluded from future searches and auto-expire after 90 days.",
@@ -39507,7 +40307,7 @@ function registerTools(server, scout) {
           const count = scout.getSkippedIssues().length;
           scout.clearSkippedIssues();
           const synced2 = await scout.checkpoint();
-          const syncNote2 = synced2 ? "" : " (saved locally, gist sync failed)";
+          const syncNote2 = synced2 ? "" : " (warning: failed to persist to disk)";
           return {
             content: [
               {
@@ -39521,7 +40321,7 @@ function registerTools(server, scout) {
           const wasPresent = scout.getSkippedIssues().some((s) => s.url === issueUrl);
           scout.unskipIssue(issueUrl);
           const synced2 = await scout.checkpoint();
-          const syncNote2 = synced2 ? "" : " (saved locally, gist sync failed)";
+          const syncNote2 = synced2 ? "" : " (warning: failed to persist to disk)";
           return {
             content: [
               {
@@ -39531,6 +40331,8 @@ function registerTools(server, scout) {
             ]
           };
         }
+        validateUrl(issueUrl);
+        validateGitHubUrl(issueUrl, ISSUE_URL_PATTERN, "issue");
         const alreadySkipped = scout.getSkippedIssues().some((s) => s.url === issueUrl);
         if (alreadySkipped) {
           return {
@@ -39547,7 +40349,7 @@ function registerTools(server, scout) {
         } : void 0;
         scout.skipIssue(issueUrl, metadata);
         const synced = await scout.checkpoint();
-        const syncNote = synced ? "" : " (saved locally, gist sync failed)";
+        const syncNote = synced ? "" : " (warning: failed to persist to disk)";
         return {
           content: [{ type: "text", text: `Skipped: ${issueUrl}${syncNote}` }]
         };
@@ -39560,105 +40362,44 @@ function registerTools(server, scout) {
       }
     }
   );
-  const VALID_KEYS = Object.keys(ScoutPreferencesSchema.shape);
-  const ARRAY_KEYS = /* @__PURE__ */ new Set([
-    "languages",
-    "labels",
-    "projectCategories",
-    "excludeRepos",
-    "excludeOrgs",
-    "aiPolicyBlocklist",
-    "scope",
-    "defaultStrategy"
-  ]);
-  const NUMBER_KEYS = /* @__PURE__ */ new Set([
-    "minStars",
-    "maxIssueAgeDays",
-    "minRepoScoreThreshold",
-    "interPhaseDelayMs",
-    "broadPhaseDelayMs",
-    "skipBroadWhenSufficientResults",
-    "featuresAnchorThreshold",
-    "featuresSplitRatio"
-  ]);
-  const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["includeDocIssues"]);
   server.tool(
     "config-set",
     "Update an oss-scout configuration preference",
     {
       key: external_exports3.string().describe(
-        "Preference key to update (e.g. languages, minStars, excludeRepos)"
+        `Preference key to update. One of: ${SORTED_PREFERENCE_KEYS.join(", ")}`
       ),
       value: external_exports3.string().describe(
-        "New value \u2014 comma-separated for arrays, plain string for scalars"
+        'New value. Comma-separated for arrays; prefix with + to append or - to remove items (e.g. "+spam/repo"). Plain string/number/boolean for scalars.'
       )
     },
     async ({ key, value }) => {
-      if (!VALID_KEYS.includes(key)) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Unknown config key: "${key}". Valid keys: ${VALID_KEYS.join(", ")}`
-            }
-          ],
-          isError: true
-        };
-      }
-      let parsed;
-      if (ARRAY_KEYS.has(key)) {
-        try {
-          parsed = JSON.parse(value);
-          if (!Array.isArray(parsed)) {
-            parsed = value.split(",").map((s) => s.trim()).filter(Boolean);
-          }
-        } catch {
-          parsed = value.split(",").map((s) => s.trim()).filter(Boolean);
-        }
-      } else if (NUMBER_KEYS.has(key)) {
-        const num = Number(value);
-        if (isNaN(num)) {
-          return {
-            content: [
-              { type: "text", text: `Invalid number for "${key}": "${value}"` }
-            ],
-            isError: true
-          };
-        }
-        parsed = num;
-      } else if (BOOLEAN_KEYS.has(key)) {
-        const lower = value.toLowerCase();
-        if (lower === "true" || lower === "yes") parsed = true;
-        else if (lower === "false" || lower === "no") parsed = false;
-        else {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `Invalid boolean for "${key}": "${value}". Use true/false or yes/no.`
-              }
-            ],
-            isError: true
-          };
-        }
-      } else {
-        parsed = value;
-      }
-      const currentPrefs = scout.getPreferences();
-      const candidate = { ...currentPrefs, [key]: parsed };
-      const result = ScoutPreferencesSchema.safeParse(candidate);
-      if (!result.success) {
-        const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+      let validated;
+      try {
+        validated = applyPreferenceField(scout.getPreferences(), key, value);
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
         return {
-          content: [{ type: "text", text: `Validation error: ${issues}` }],
+          content: [{ type: "text", text: msg }],
           isError: true
         };
       }
-      scout.updatePreferences({ [key]: parsed });
-      await scout.checkpoint();
+      scout.updatePreferences({
+        [key]: validated[key]
+      });
+      const persisted = await scout.checkpoint();
       const updated = scout.getPreferences();
       return {
-        content: [{ type: "text", text: JSON.stringify(updated, null, 2) }]
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              withPersistWarning(updated, persisted),
+              null,
+              2
+            )
+          }
+        ]
       };
     }
   );
@@ -39714,25 +40455,34 @@ function registerResources(server, scout) {
 }
 
 // src/index.ts
-async function main() {
-  const token = getGitHubToken();
-  if (!token) {
-    process.stderr.write(
-      "oss-scout-mcp: GitHub token required.\nSet GITHUB_TOKEN or run `gh auth login`.\n"
-    );
-    process.exit(1);
-  }
-  const scout = await createScout({ githubToken: token });
+var SERVER_INFO = {
+  name: "oss-scout-mcp",
+  version: "0.10.0"
+  // x-release-please-version
+};
+function createServer(scout) {
   const server = new McpServer(
-    { name: "oss-scout-mcp", version: "0.2.1" },
+    { name: SERVER_INFO.name, version: SERVER_INFO.version },
     { capabilities: { resources: {}, tools: {} } }
   );
   registerTools(server, scout);
   registerResources(server, scout);
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
+  return server;
+}
+async function runServer() {
+  const token = getGitHubToken();
+  if (!token) {
+    throw new Error(
+      "GitHub token required. Set GITHUB_TOKEN or run `gh auth login`."
+    );
+  }
+  const scout = await createScout({ githubToken: token, persistence: "local" });
+  const server = createServer(scout);
+  await server.connect(new StdioServerTransport());
 }
-main().catch((err) => {
+
+// src/bin.ts
+runServer().catch((err) => {
   process.stderr.write(
     `oss-scout-mcp fatal: ${err instanceof Error ? err.message : String(err)}
 `