@oss-scout/mcp 0.4.0 → 0.6.0

package/dist/mcp-server.bundle.cjs

@@ -3099,12 +3099,15 @@ var require_data = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js
 var require_utils = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/utils.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/utils.js"(exports2, module2) {
     "use strict";
     var isUUID = RegExp.prototype.test.bind(/^[\da-f]{8}-[\da-f]{4}-[\da-f]{4}-[\da-f]{4}-[\da-f]{12}$/iu);
     var isIPv4 = RegExp.prototype.test.bind(/^(?:(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)\.){3}(?:25[0-5]|2[0-4]\d|1\d{2}|[1-9]\d|\d)$/u);
+    var isHexPair = RegExp.prototype.test.bind(/^[\da-f]{2}$/iu);
+    var isUnreserved = RegExp.prototype.test.bind(/^[\da-z\-._~]$/iu);
+    var isPathCharacter = RegExp.prototype.test.bind(/^[\da-z\-._~!$&'()*+,;=:@/]$/iu);
     function stringArrayToHexStripped(input) {
       let acc = "";
       let code = 0;
@@ -3297,27 +3300,77 @@ var require_utils = __commonJS({
       }
       return output.join("");
     }
-    function normalizeComponentEncoding(component, esc2) {
-      const func = esc2 !== true ? escape : unescape;
-      if (component.scheme !== void 0) {
-        component.scheme = func(component.scheme);
-      }
-      if (component.userinfo !== void 0) {
-        component.userinfo = func(component.userinfo);
-      }
-      if (component.host !== void 0) {
-        component.host = func(component.host);
+    var HOST_DELIMS = { "@": "%40", "/": "%2F", "?": "%3F", "#": "%23", ":": "%3A" };
+    var HOST_DELIM_RE = /[@/?#:]/g;
+    var HOST_DELIM_NO_COLON_RE = /[@/?#]/g;
+    function reescapeHostDelimiters(host, isIP) {
+      const re = isIP ? HOST_DELIM_NO_COLON_RE : HOST_DELIM_RE;
+      re.lastIndex = 0;
+      return host.replace(re, (ch) => HOST_DELIMS[ch]);
+    }
+    function normalizePercentEncoding(input, decodeUnreserved = false) {
+      if (input.indexOf("%") === -1) {
+        return input;
       }
-      if (component.path !== void 0) {
-        component.path = func(component.path);
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decodeUnreserved && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        output += input[i];
       }
-      if (component.query !== void 0) {
-        component.query = func(component.query);
+      return output;
+    }
+    function normalizePathEncoding(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            const normalizedHex = hex3.toUpperCase();
+            const decoded = String.fromCharCode(parseInt(normalizedHex, 16));
+            if (decoded !== "." && isUnreserved(decoded)) {
+              output += decoded;
+            } else {
+              output += "%" + normalizedHex;
+            }
+            i += 2;
+            continue;
+          }
+        }
+        if (isPathCharacter(input[i])) {
+          output += input[i];
+        } else {
+          output += escape(input[i]);
+        }
       }
-      if (component.fragment !== void 0) {
-        component.fragment = func(component.fragment);
+      return output;
+    }
+    function escapePreservingEscapes(input) {
+      let output = "";
+      for (let i = 0; i < input.length; i++) {
+        if (input[i] === "%" && i + 2 < input.length) {
+          const hex3 = input.slice(i + 1, i + 3);
+          if (isHexPair(hex3)) {
+            output += "%" + hex3.toUpperCase();
+            i += 2;
+            continue;
+          }
+        }
+        output += escape(input[i]);
       }
-      return component;
+      return output;
     }
     function recomposeAuthority(component) {
       const uriTokens = [];
@@ -3332,7 +3385,7 @@ var require_utils = __commonJS({
           if (ipV6res.isIPV6 === true) {
             host = `[${ipV6res.escapedHost}]`;
           } else {
-            host = component.host;
+            host = reescapeHostDelimiters(host, false);
           }
         }
         uriTokens.push(host);
@@ -3346,7 +3399,10 @@ var require_utils = __commonJS({
     module2.exports = {
       nonSimpleDomain,
       recomposeAuthority,
-      normalizeComponentEncoding,
+      reescapeHostDelimiters,
+      normalizePercentEncoding,
+      normalizePathEncoding,
+      escapePreservingEscapes,
       removeDotSegments,
       isIPv4,
       isUUID,
@@ -3356,9 +3412,9 @@ var require_utils = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js
 var require_schemes = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/lib/schemes.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/lib/schemes.js"(exports2, module2) {
     "use strict";
     var { isUUID } = require_utils();
     var URN_REG = /([\da-z][\d\-a-z]{0,31}):((?:[\w!$'()*+,\-.:;=@]|%[\da-f]{2})+)/iu;
@@ -3566,16 +3622,16 @@ var require_schemes = __commonJS({
   }
 });
 
-// ../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js
+// ../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js
 var require_fast_uri = __commonJS({
-  "../../node_modules/.pnpm/fast-uri@3.1.0/node_modules/fast-uri/index.js"(exports2, module2) {
+  "../../node_modules/.pnpm/fast-uri@3.1.2/node_modules/fast-uri/index.js"(exports2, module2) {
     "use strict";
-    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizeComponentEncoding, isIPv4, nonSimpleDomain } = require_utils();
+    var { normalizeIPv6, removeDotSegments, recomposeAuthority, normalizePercentEncoding, normalizePathEncoding, escapePreservingEscapes, reescapeHostDelimiters, isIPv4, nonSimpleDomain } = require_utils();
     var { SCHEMES, getSchemeHandler } = require_schemes();
     function normalize(uri, options) {
       if (typeof uri === "string") {
         uri = /** @type {T} */
-        serialize(parse4(uri, options), options);
+        normalizeString(uri, options);
       } else if (typeof uri === "object") {
         uri = /** @type {T} */
         parse4(serialize(uri, options), options);
@@ -3642,19 +3698,9 @@ var require_fast_uri = __commonJS({
       return target;
     }
     function equal(uriA, uriB, options) {
-      if (typeof uriA === "string") {
-        uriA = unescape(uriA);
-        uriA = serialize(normalizeComponentEncoding(parse4(uriA, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriA === "object") {
-        uriA = serialize(normalizeComponentEncoding(uriA, true), { ...options, skipEscape: true });
-      }
-      if (typeof uriB === "string") {
-        uriB = unescape(uriB);
-        uriB = serialize(normalizeComponentEncoding(parse4(uriB, options), true), { ...options, skipEscape: true });
-      } else if (typeof uriB === "object") {
-        uriB = serialize(normalizeComponentEncoding(uriB, true), { ...options, skipEscape: true });
-      }
-      return uriA.toLowerCase() === uriB.toLowerCase();
+      const normalizedA = normalizeComparableURI(uriA, options);
+      const normalizedB = normalizeComparableURI(uriB, options);
+      return normalizedA !== void 0 && normalizedB !== void 0 && normalizedA.toLowerCase() === normalizedB.toLowerCase();
     }
     function serialize(cmpts, opts) {
       const component = {
@@ -3679,12 +3725,12 @@ var require_fast_uri = __commonJS({
       if (schemeHandler && schemeHandler.serialize) schemeHandler.serialize(component, options);
       if (component.path !== void 0) {
         if (!options.skipEscape) {
-          component.path = escape(component.path);
+          component.path = escapePreservingEscapes(component.path);
           if (component.scheme !== void 0) {
             component.path = component.path.split("%3A").join(":");
           }
         } else {
-          component.path = unescape(component.path);
+          component.path = normalizePercentEncoding(component.path);
         }
       }
       if (options.reference !== "suffix" && component.scheme) {
@@ -3719,7 +3765,16 @@ var require_fast_uri = __commonJS({
       return uriTokens.join("");
     }
     var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
-    function parse4(uri, opts) {
+    function getParseError(parsed, matches) {
+      if (matches[2] !== void 0 && parsed.path && parsed.path[0] !== "/") {
+        return 'URI path must start with "/" when authority is present.';
+      }
+      if (typeof parsed.port === "number" && (parsed.port < 0 || parsed.port > 65535)) {
+        return "URI port is malformed.";
+      }
+      return void 0;
+    }
+    function parseWithStatus(uri, opts) {
       const options = Object.assign({}, opts);
       const parsed = {
         scheme: void 0,
@@ -3730,6 +3785,7 @@ var require_fast_uri = __commonJS({
         query: void 0,
         fragment: void 0
       };
+      let malformedAuthorityOrPort = false;
       let isIP = false;
       if (options.reference === "suffix") {
         if (options.scheme) {
@@ -3750,6 +3806,11 @@ var require_fast_uri = __commonJS({
         if (isNaN(parsed.port)) {
           parsed.port = matches[5];
         }
+        const parseError = getParseError(parsed, matches);
+        if (parseError !== void 0) {
+          parsed.error = parsed.error || parseError;
+          malformedAuthorityOrPort = true;
+        }
         if (parsed.host) {
           const ipv4result = isIPv4(parsed.host);
           if (ipv4result === false) {
@@ -3788,14 +3849,18 @@ var require_fast_uri = __commonJS({
               parsed.scheme = unescape(parsed.scheme);
             }
             if (parsed.host !== void 0) {
-              parsed.host = unescape(parsed.host);
+              parsed.host = reescapeHostDelimiters(unescape(parsed.host), isIP);
             }
           }
           if (parsed.path) {
-            parsed.path = escape(unescape(parsed.path));
+            parsed.path = normalizePathEncoding(parsed.path);
           }
           if (parsed.fragment) {
-            parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            try {
+              parsed.fragment = encodeURI(decodeURIComponent(parsed.fragment));
+            } catch {
+              parsed.error = parsed.error || "URI malformed";
+            }
           }
         }
         if (schemeHandler && schemeHandler.parse) {
@@ -3804,7 +3869,29 @@ var require_fast_uri = __commonJS({
       } else {
         parsed.error = parsed.error || "URI can not be parsed.";
       }
-      return parsed;
+      return { parsed, malformedAuthorityOrPort };
+    }
+    function parse4(uri, opts) {
+      return parseWithStatus(uri, opts).parsed;
+    }
+    function normalizeString(uri, opts) {
+      return normalizeStringWithStatus(uri, opts).normalized;
+    }
+    function normalizeStringWithStatus(uri, opts) {
+      const { parsed, malformedAuthorityOrPort } = parseWithStatus(uri, opts);
+      return {
+        normalized: malformedAuthorityOrPort ? uri : serialize(parsed, opts),
+        malformedAuthorityOrPort
+      };
+    }
+    function normalizeComparableURI(uri, opts) {
+      if (typeof uri === "string") {
+        const { normalized, malformedAuthorityOrPort } = normalizeStringWithStatus(uri, opts);
+        return malformedAuthorityOrPort ? void 0 : normalized;
+      }
+      if (typeof uri === "object") {
+        return serialize(uri, opts);
+      }
     }
     var fastUri = {
       SCHEMES,
@@ -32107,8 +32194,8 @@ function isPlainObject4(value) {
 }
 var noop = () => "";
 async function fetchWrapper(requestOptions) {
-  const fetch = requestOptions.request?.fetch || globalThis.fetch;
-  if (!fetch) {
+  const fetch2 = requestOptions.request?.fetch || globalThis.fetch;
+  if (!fetch2) {
     throw new Error(
       "fetch is not set. Please pass a fetch implementation as new Octokit({ request: { fetch }}). Learn more at https://github.com/octokit/octokit.js/#fetch-missing"
     );
@@ -32124,7 +32211,7 @@ async function fetchWrapper(requestOptions) {
   );
   let fetchResponse;
   try {
-    fetchResponse = await fetch(requestOptions.url, {
+    fetchResponse = await fetch2(requestOptions.url, {
       method: requestOptions.method,
       body,
       redirect: requestOptions.request?.redirect,
@@ -35742,6 +35829,11 @@ var StoredClosedPRSchema = external_exports3.object({
   title: external_exports3.string(),
   closedAt: external_exports3.string()
 });
+var StoredOpenPRSchema = external_exports3.object({
+  url: external_exports3.string(),
+  title: external_exports3.string(),
+  openedAt: external_exports3.string()
+});
 var ContributionGuidelinesSchema = external_exports3.object({
   branchNamingConvention: external_exports3.string().optional(),
   commitMessageFormat: external_exports3.string().optional(),
@@ -35758,6 +35850,19 @@ var ContributionGuidelinesSchema = external_exports3.object({
   claRequired: external_exports3.boolean().optional(),
   rawContent: external_exports3.string().optional()
 });
+var LinkedPRSchema = external_exports3.object({
+  number: external_exports3.number(),
+  author: external_exports3.string(),
+  state: external_exports3.enum(["open", "closed"]),
+  merged: external_exports3.boolean(),
+  url: external_exports3.string(),
+  /**
+   * ISO-8601 timestamp of the linked PR's last update. Optional so existing
+   * persisted state validates unchanged. Used by `isLinkedPRStalled` to
+   * surface stale revive opportunities (#97).
+   */
+  updatedAt: external_exports3.string().optional()
+});
 var IssueVettingResultSchema = external_exports3.object({
   passedAllChecks: external_exports3.boolean(),
   checks: external_exports3.object({
@@ -35768,6 +35873,7 @@ var IssueVettingResultSchema = external_exports3.object({
     contributionGuidelinesFound: external_exports3.boolean()
   }),
   contributionGuidelines: ContributionGuidelinesSchema.optional(),
+  linkedPR: LinkedPRSchema.nullable().optional(),
   notes: external_exports3.array(external_exports3.string())
 });
 var TrackedIssueSchema = external_exports3.object({
@@ -35790,6 +35896,7 @@ var SkippedIssueSchema = external_exports3.object({
   title: external_exports3.string(),
   skippedAt: external_exports3.string()
 });
+var HorizonSchema = external_exports3.enum(["quick-win", "bigger-bet"]);
 var SavedCandidateSchema = external_exports3.object({
   issueUrl: external_exports3.string(),
   repo: external_exports3.string(),
@@ -35801,7 +35908,8 @@ var SavedCandidateSchema = external_exports3.object({
   searchPriority: external_exports3.string(),
   firstSeenAt: external_exports3.string(),
   lastSeenAt: external_exports3.string(),
-  lastScore: external_exports3.number()
+  lastScore: external_exports3.number(),
+  horizon: HorizonSchema.optional()
 });
 var PersistenceModeSchema = external_exports3.enum(["local", "gist"]);
 var ScoutPreferencesSchema = external_exports3.object({
@@ -35821,7 +35929,32 @@ var ScoutPreferencesSchema = external_exports3.object({
   persistence: PersistenceModeSchema.default("local"),
   defaultStrategy: external_exports3.array(SearchStrategySchema).optional(),
   broadPhaseDelayMs: external_exports3.number().min(0).max(3e5).default(9e4),
-  skipBroadWhenSufficientResults: external_exports3.number().int().min(0).max(100).default(15)
+  skipBroadWhenSufficientResults: external_exports3.number().int().min(0).max(100).default(15),
+  /**
+   * Optional Ollama model id used for SLM pre-triage during vetting
+   * (oss-autopilot#1122). Empty disables the feature. Recommended values:
+   * `gemma4:e4b` (default for capable hardware) or `gemma4:e2b` /
+   * `qwen3:1.7b` for low-RAM machines.
+   */
+  slmTriageModel: external_exports3.string().default(""),
+  /**
+   * Override the Ollama HTTP host. Defaults to `http://127.0.0.1:11434`
+   * when empty. Useful when Ollama runs on a different machine on the
+   * local network.
+   */
+  slmTriageHost: external_exports3.string().default(""),
+  /**
+   * Minimum merged-PR count for a repo to qualify as an anchor in
+   * `scout features` (#98). Lowering surfaces more anchors at the cost
+   * of weaker prior engagement signal.
+   */
+  featuresAnchorThreshold: external_exports3.number().int().min(1).max(50).default(3),
+  /**
+   * Quick-wins / bigger-bets split ratio for `scout features` (#99).
+   * 0.6 means 60% quick wins, 40% bigger bets when both pools are
+   * abundant. Deficits redirect to the other bucket.
+   */
+  featuresSplitRatio: external_exports3.number().min(0).max(1).default(0.6)
 });
 var ScoutStateSchema = external_exports3.object({
   version: external_exports3.literal(1),
@@ -35831,6 +35964,7 @@ var ScoutStateSchema = external_exports3.object({
   starredReposLastFetched: external_exports3.string().optional(),
   mergedPRs: external_exports3.array(StoredMergedPRSchema).default([]),
   closedPRs: external_exports3.array(StoredClosedPRSchema).default([]),
+  openPRs: external_exports3.array(StoredOpenPRSchema).default([]),
   savedResults: external_exports3.array(SavedCandidateSchema).default([]),
   skippedIssues: external_exports3.array(SkippedIssueSchema).default([]),
   lastSearchAt: external_exports3.string().optional(),
@@ -35966,6 +36100,16 @@ function calculateViabilityScore(params) {
   if (params.closedWithoutMergeCount > 0 && params.mergedPRCount === 0) {
     score -= 15;
   }
+  if (params.featureSignals) {
+    const fs5 = params.featureSignals;
+    score += Math.min(Math.floor(fs5.reactions / 2), 10);
+    if (fs5.comments >= 5)
+      score += 5;
+    if (fs5.hasMilestone)
+      score += 5;
+    if (fs5.wontfixNoContributor)
+      score += 10;
+  }
   return Math.max(0, Math.min(100, score));
 }
 
@@ -36357,6 +36501,35 @@ function isNotModifiedError(err) {
 }
 
 // ../core/dist/core/issue-eligibility.js
+function isLinkedPREvent(e) {
+  return e.event === "cross-referenced" && !!e.source?.issue?.pull_request;
+}
+function buildLinkedPRFromTimelineEvent(e, context) {
+  const issue2 = e.source?.issue;
+  const ctx = `${context.owner}/${context.repo}#${context.issueNumber}`;
+  if (!issue2 || typeof issue2.number !== "number") {
+    warn(MODULE5, `Cross-referenced timeline event for ${ctx} missing source.issue.number \u2014 possible API shape drift`);
+    return null;
+  }
+  const author = issue2.user?.login;
+  if (!author) {
+    warn(MODULE5, `Cross-referenced PR #${issue2.number} for ${ctx} has no user.login (deleted user?) \u2014 skipping linkedPR metadata`);
+    return null;
+  }
+  const url2 = issue2.html_url;
+  if (!url2) {
+    warn(MODULE5, `Cross-referenced PR #${issue2.number} for ${ctx} missing html_url \u2014 skipping linkedPR metadata`);
+    return null;
+  }
+  return {
+    number: issue2.number,
+    author,
+    state: issue2.state === "closed" ? "closed" : "open",
+    merged: !!issue2.pull_request?.merged_at,
+    url: url2,
+    updatedAt: issue2.updated_at
+  };
+}
 var MODULE5 = "issue-eligibility";
 var CLAIM_PHRASES = [
   "i'm working on this",
@@ -36384,15 +36557,27 @@ async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
       per_page: 100,
       page
     }));
-    const linkedPRs = timeline.filter((event) => {
+    let linkedPRCount = 0;
+    let linkedPR = null;
+    for (const event of timeline) {
       const e = event;
-      return e.event === "cross-referenced" && e.source?.issue?.pull_request;
-    });
-    return { passed: linkedPRs.length === 0 };
+      if (!isLinkedPREvent(e))
+        continue;
+      linkedPRCount++;
+      linkedPR ??= buildLinkedPRFromTimelineEvent(e, {
+        owner,
+        repo,
+        issueNumber
+      });
+    }
+    return { passed: linkedPRCount === 0, linkedPR };
   } catch (error48) {
+    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+      throw 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 };
+    return { passed: true, inconclusive: true, reason: errMsg, linkedPR: null };
   }
 }
 var MERGED_PR_CACHE_TTL_MS = 15 * 60 * 1e3;
@@ -36418,6 +36603,9 @@ async function checkUserMergedPRsInRepo(octokit, owner, repo) {
       tracker.recordCall();
     }
   } catch (error48) {
+    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+      throw error48;
+    }
     const errMsg = errorMessage(error48);
     warn(MODULE5, `Could not check merged PRs in ${owner}/${repo}: ${errMsg}. Defaulting to 0.`);
     return 0;
@@ -36442,6 +36630,9 @@ async function checkNotClaimed(octokit, owner, repo, issueNumber, commentCount)
     }
     return { passed: true };
   } catch (error48) {
+    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+      throw 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 };
@@ -36514,6 +36705,9 @@ async function checkProjectHealth(octokit, owner, repo) {
       };
     });
   } catch (error48) {
+    if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+      throw error48;
+    }
     const errMsg = errorMessage(error48);
     warn(MODULE6, `Error checking project health for ${owner}/${repo}: ${errMsg}`);
     return {
@@ -36547,6 +36741,13 @@ async function fetchContributionGuidelines(octokit, owner, repo) {
     }
     return null;
   })));
+  for (const result of results) {
+    if (result.status !== "rejected")
+      continue;
+    if (getHttpStatusCode(result.reason) === 401 || isRateLimitError(result.reason)) {
+      throw result.reason;
+    }
+  }
   for (let i = 0; i < results.length; i++) {
     const result = results[i];
     if (result.status === "fulfilled" && result.value) {
@@ -36556,9 +36757,9 @@ async function fetchContributionGuidelines(octokit, owner, repo) {
       return guidelines;
     }
     if (result.status === "rejected") {
-      const msg = result.reason instanceof Error ? result.reason.message : String(result.reason);
-      if (!msg.includes("404") && !msg.includes("Not Found")) {
-        warn(MODULE6, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${msg}`);
+      const status = getHttpStatusCode(result.reason);
+      if (status !== 404) {
+        warn(MODULE6, `Unexpected error fetching ${filesToCheck[i]} from ${owner}/${repo}: ${errorMessage(result.reason)}`);
       }
     }
   }
@@ -36608,8 +36809,274 @@ function parseContributionGuidelines(content) {
   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",
+  "no ai generated",
+  "no ai-assisted",
+  "no ai assisted",
+  "no llm-generated",
+  "no llm generated",
+  "no copilot-generated",
+  "no chatgpt-generated",
+  "human-authored only",
+  "human authored only",
+  "human-written only",
+  "human written only",
+  "ai-free contributions",
+  "llm-free contributions",
+  "ai-generated code is not allowed",
+  "ai-generated code will not be accepted",
+  "do not submit ai-generated",
+  "do not submit llm-generated",
+  "do not use ai to",
+  "do not use llms",
+  "do not use copilot",
+  "do not use chatgpt",
+  "without ai assistance",
+  "without llm assistance",
+  "no use of generative ai",
+  "ban on ai-generated",
+  "prohibit ai-generated",
+  "prohibits ai-generated"
+];
+function scanForAntiLLMPolicy(text) {
+  if (!text)
+    return { matched: false, matchedKeywords: [] };
+  const haystack = text.toLowerCase();
+  const matchedKeywords = ANTI_LLM_KEYWORDS.filter((kw) => haystack.includes(kw));
+  return { matched: matchedKeywords.length > 0, matchedKeywords };
+}
+var SOURCE_FILE_FAMILIES = [
+  {
+    canonical: "CONTRIBUTING.md",
+    paths: [
+      "CONTRIBUTING.md",
+      ".github/CONTRIBUTING.md",
+      "docs/CONTRIBUTING.md",
+      "contributing.md"
+    ]
+  },
+  {
+    canonical: "CODE_OF_CONDUCT.md",
+    paths: [
+      "CODE_OF_CONDUCT.md",
+      ".github/CODE_OF_CONDUCT.md",
+      "docs/CODE_OF_CONDUCT.md",
+      "code_of_conduct.md"
+    ]
+  },
+  {
+    canonical: "README.md",
+    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)));
+  let hadTransientFailure = false;
+  for (const result of results) {
+    if (result.status === "fulfilled") {
+      if (result.value.transient)
+        hadTransientFailure = true;
+      if (result.value.text)
+        return { text: result.value.text, hadTransientFailure };
+    } else {
+      if (isRateLimitError(result.reason) || getHttpStatusCode(result.reason) === 401) {
+        throw result.reason;
+      }
+      hadTransientFailure = true;
+    }
+  }
+  return { text: null, hadTransientFailure };
+}
+function isAntiLLMPolicyResult(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const v = value;
+  if (typeof v.matched !== "boolean")
+    return false;
+  if (!Array.isArray(v.matchedKeywords))
+    return false;
+  if (v.sourceFile !== null && typeof v.sourceFile !== "string")
+    return false;
+  return true;
+}
+async function fetchAndScanAntiLLMPolicy(octokit, owner, repo, options) {
+  const cache = getHttpCache();
+  const cacheKey = `anti-llm-policy:${owner}/${repo}`;
+  const cached2 = cache.getIfFresh(cacheKey, POLICY_SCAN_CACHE_TTL_MS);
+  if (isAntiLLMPolicyResult(cached2))
+    return cached2;
+  let anyTransientFailure = false;
+  for (const family of SOURCE_FILE_FAMILIES) {
+    let text;
+    let hadTransientFailure = false;
+    if (family.canonical === "CONTRIBUTING.md" && options?.contributingText !== void 0) {
+      text = options.contributingText;
+    } else {
+      ({ text, hadTransientFailure } = await fetchFamilyText(octokit, owner, repo, family.paths));
+    }
+    if (hadTransientFailure)
+      anyTransientFailure = true;
+    if (!text)
+      continue;
+    const { matched, matchedKeywords } = scanForAntiLLMPolicy(text);
+    if (matched) {
+      const result = {
+        matched: true,
+        matchedKeywords,
+        sourceFile: family.canonical
+      };
+      cache.set(cacheKey, "", result);
+      return result;
+    }
+  }
+  const noMatch = {
+    matched: false,
+    matchedKeywords: [],
+    sourceFile: null
+  };
+  if (!anyTransientFailure) {
+    cache.set(cacheKey, "", noMatch);
+  }
+  return noMatch;
+}
+
+// ../core/dist/core/slm-triage.js
+var DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
+var DEFAULT_TIMEOUT_MS = 15e3;
+var MAX_BODY_CHARS = 2e3;
+var SLM_TRIAGE_SCHEMA = {
+  type: "object",
+  properties: {
+    decision: { type: "string", enum: ["pursue", "investigate", "skip"] },
+    confidence: { type: "string", enum: ["high", "medium", "low"] },
+    reasons: {
+      type: "array",
+      items: { type: "string" },
+      minItems: 1,
+      maxItems: 3
+    }
+  },
+  required: ["decision", "confidence", "reasons"]
+};
+function buildPrompt(input) {
+  const { issue: issue2, linkedPRExists } = input;
+  const body = (issue2.body ?? "").slice(0, MAX_BODY_CHARS);
+  return [
+    "You triage open-source issues for an autonomous contribution agent.",
+    "Classify the issue into exactly one bucket:",
+    "- pursue: small, concrete bug or feature with clear acceptance; safe for an autonomous agent to attempt without further design input",
+    "- investigate: tractable but needs human reading first (ambiguous scope, design questions, recently-touched files)",
+    "- skip: not actionable autonomously (epic, creative, blocked, requires upstream change, requires infra)",
+    "",
+    "Return JSON only matching the provided schema. Reasons must be short phrases, not sentences. 1-3 reasons total.",
+    "",
+    "Issue:",
+    `Title: ${issue2.title}`,
+    `Body: ${body}`,
+    `Labels: ${issue2.labels.join(", ")}`,
+    `Linked PR exists: ${linkedPRExists}`
+  ].join("\n");
+}
+async function triageWithSLM(input, options) {
+  if (!options.model)
+    return null;
+  const host = options.host ?? DEFAULT_OLLAMA_HOST;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const fetchFn = options.fetchImpl ?? fetch;
+  let response;
+  try {
+    response = await fetchFn(`${host}/api/chat`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        model: options.model,
+        messages: [{ role: "user", content: buildPrompt(input) }],
+        stream: false,
+        format: SLM_TRIAGE_SCHEMA,
+        options: { temperature: 0.1 }
+      }),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+  } catch {
+    return null;
+  }
+  if (!response.ok)
+    return null;
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    return null;
+  }
+  const content = payload?.message?.content;
+  if (typeof content !== "string")
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return null;
+  }
+  if (!isValidTriageShape(parsed))
+    return null;
+  return {
+    decision: parsed.decision,
+    confidence: parsed.confidence,
+    reasons: parsed.reasons,
+    modelVersion: options.model
+  };
+}
+function buildTriageInput(args) {
+  return {
+    issue: {
+      title: args.issue.title,
+      labels: args.issue.labels,
+      body: args.issue.body
+    },
+    linkedPRExists: !!args.linkedPR
+  };
+}
+function isValidTriageShape(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  if (v.decision !== "pursue" && v.decision !== "investigate" && v.decision !== "skip")
+    return false;
+  if (v.confidence !== "high" && v.confidence !== "medium" && v.confidence !== "low")
+    return false;
+  if (!Array.isArray(v.reasons) || v.reasons.length === 0 || v.reasons.length > 3)
+    return false;
+  if (!v.reasons.every((r) => typeof r === "string"))
+    return false;
+  return true;
+}
+
 // ../core/dist/core/issue-vetting.js
-var MODULE7 = "issue-vetting";
+var MODULE8 = "issue-vetting";
 var MAX_CONCURRENT_VETTING = 3;
 var VETTING_CACHE_TTL_MS = 15 * 60 * 1e3;
 var IssueVetter = class {
@@ -36622,13 +37089,19 @@ var IssueVetter = class {
   /**
    * Vet a specific issue — runs all checks and computes recommendation + viability score.
    * Results are cached for 15 minutes to avoid redundant API calls on repeated searches.
+   *
+   * `opts.featureSignals` are forwarded directly to scoring; the vetter does
+   * not derive them from the fetched issue. Cache key includes a digest of
+   * the signals so the same URL with different signals doesn't return a
+   * stale score.
    */
-  async vetIssue(issueUrl) {
+  async vetIssue(issueUrl, opts) {
     const cache = getHttpCache();
-    const cacheKey = `vet:${issueUrl}`;
+    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 cached2 = cache.getIfFresh(cacheKey, VETTING_CACHE_TTL_MS);
     if (cached2 && typeof cached2 === "object" && "issue" in cached2 && "viabilityScore" in cached2) {
-      debug(MODULE7, `Vetting cache hit for ${issueUrl}`);
+      debug(MODULE8, `Vetting cache hit for ${issueUrl}`);
       return cached2;
     }
     const parsed = parseGitHubUrl(issueUrl);
@@ -36651,6 +37124,7 @@ var IssueVetter = class {
       fetchContributionGuidelines(this.octokit, owner, repo),
       hasMergedPRsInRepo ? Promise.resolve(0) : checkUserMergedPRsInRepo(this.octokit, owner, repo)
     ]);
+    const antiLLMPolicy = await fetchAndScanAntiLLMPolicy(this.octokit, owner, repo, { contributingText: contributionGuidelines?.rawContent });
     const noExistingPR = existingPRCheck.passed;
     const notClaimed = claimCheck.passed;
     const clearRequirements = analyzeRequirements(ghIssue.body || "");
@@ -36665,6 +37139,7 @@ var IssueVetter = class {
         contributionGuidelinesFound: !!contributionGuidelines
       },
       contributionGuidelines,
+      linkedPR: existingPRCheck.linkedPR,
       notes: []
     };
     if (!noExistingPR)
@@ -36765,7 +37240,8 @@ var IssueVetter = class {
       mergedPRCount: effectiveMergedCount,
       orgHasMergedPRs,
       repoQualityBonus,
-      matchesPreferredCategory: matchesCategory
+      matchesPreferredCategory: matchesCategory,
+      featureSignals: opts?.featureSignals
     });
     const starredRepos = this.stateReader.getStarredRepos();
     let searchPriority = "normal";
@@ -36774,10 +37250,26 @@ var IssueVetter = class {
     } else if (starredRepos.includes(repoFullName)) {
       searchPriority = "starred";
     }
+    const slmConfig = this.stateReader.getSLMTriageConfig?.() ?? {
+      model: "",
+      host: ""
+    };
+    let slmTriage = null;
+    if (slmConfig.model) {
+      const slmOpts = { model: slmConfig.model };
+      if (slmConfig.host)
+        slmOpts.host = slmConfig.host;
+      slmTriage = await triageWithSLM(buildTriageInput({
+        issue: { ...trackedIssue, body: ghIssue.body ?? "" },
+        linkedPR: existingPRCheck.linkedPR ?? null
+      }), slmOpts);
+    }
     const result = {
       issue: trackedIssue,
       vettingResult,
       projectHealth,
+      antiLLMPolicy,
+      slmTriage,
       recommendation,
       reasonsToSkip,
       reasonsToApprove,
@@ -36796,9 +37288,12 @@ var IssueVetter = class {
     let failedVettingCount = 0;
     let rateLimitFailures = 0;
     let attemptedCount = 0;
+    let firstAuthError = null;
     for (const url2 of urls) {
       if (candidates.length >= maxResults)
         break;
+      if (firstAuthError)
+        break;
       attemptedCount++;
       const task = this.vetIssue(url2).then((candidate) => {
         if (candidates.length < maxResults) {
@@ -36808,11 +37303,15 @@ var IssueVetter = class {
           candidates.push(candidate);
         }
       }).catch((error48) => {
+        if (getHttpStatusCode(error48) === 401) {
+          firstAuthError ??= error48;
+          return;
+        }
         failedVettingCount++;
         if (isRateLimitError(error48)) {
           rateLimitFailures++;
         }
-        warn(MODULE7, `Error vetting issue ${url2}:`, errorMessage(error48));
+        warn(MODULE8, `Error vetting issue ${url2}:`, errorMessage(error48));
       }).finally(() => pending.delete(url2));
       pending.set(url2, task);
       if (pending.size >= MAX_CONCURRENT_VETTING) {
@@ -36820,9 +37319,15 @@ 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`);
+      }
+      throw firstAuthError;
+    }
     const allFailed = failedVettingCount === attemptedCount && attemptedCount > 0;
     if (allFailed) {
-      warn(MODULE7, `All ${attemptedCount} issue(s) failed vetting. This may indicate a systemic issue (rate limit, auth, network).`);
+      warn(MODULE8, `All ${attemptedCount} issue(s) failed vetting. This may indicate a systemic issue (rate limit, auth, network).`);
     }
     return {
       candidates: candidates.slice(0, maxResults),
@@ -36833,14 +37338,14 @@ var IssueVetter = class {
 };
 
 // ../core/dist/core/search-phases.js
-var MODULE8 = "search-phases";
+var MODULE9 = "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(MODULE8, `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(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.`);
     }
     return [[]];
   }
@@ -36850,7 +37355,7 @@ function chunkLabels(labels, reservedOps = 0) {
   for (let i = 0; i < labels.length; i += maxPerChunk) {
     chunks.push(labels.slice(i, i + maxPerChunk));
   }
-  debug(MODULE8, `Split ${labels.length} labels into ${chunks.length} chunks (${reservedOps} ops reserved, max ${maxPerChunk} per chunk)`);
+  debug(MODULE9, `Split ${labels.length} labels into ${chunks.length} chunks (${reservedOps} ops reserved, max ${maxPerChunk} per chunk)`);
   return chunks;
 }
 function buildLabelQuery(labels) {
@@ -36887,7 +37392,7 @@ async function cachedSearchIssues(octokit, params) {
   const cache = getHttpCache();
   const cached2 = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
   if (cached2) {
-    debug(MODULE8, `Search cache hit for query`);
+    debug(MODULE9, `Search cache hit for query`);
     return cached2;
   }
   const tracker = getSearchBudgetTracker();
@@ -36902,7 +37407,7 @@ async function cachedSearchIssues(octokit, params) {
   if (data.items.length > 0) {
     cache.set(cacheKey, "", data);
   } else {
-    debug(MODULE8, `Skipping cache for empty search result (possible rate limit artifact)`);
+    debug(MODULE9, `Skipping cache for empty search result (possible rate limit artifact)`);
   }
   return data;
 }
@@ -36950,10 +37455,10 @@ async function fetchIssuesFromMaintainedRepos(octokit, repos, minStars, maxResul
       if (getHttpStatusCode(error48) === 401)
         throw error48;
       if (isRateLimitError(error48)) {
-        warn(MODULE8, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error48));
+        warn(MODULE9, `Rate limit hit fetching issues from ${repoFullName}:`, errorMessage(error48));
         break;
       }
-      warn(MODULE8, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
+      warn(MODULE9, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
     }
   }
   return items;
@@ -37004,13 +37509,13 @@ async function fetchIssuesFromKnownRepos(octokit, vetter, repos, labels, maxResu
       if (isRateLimitError(error48)) {
         rateLimitFailures++;
       }
-      warn(MODULE8, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
+      warn(MODULE9, `Error fetching issues from ${repoFullName}:`, errorMessage(error48));
     }
   }
   const allReposFailed = failedRepos === repos.length && repos.length > 0;
   const rateLimitHit = rateLimitFailures > 0;
   if (allReposFailed) {
-    warn(MODULE8, `All ${repos.length} repo(s) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
+    warn(MODULE9, `All ${repos.length} repo(s) failed for ${priority} phase. This may indicate a systemic issue (rate limit, auth, network).`);
   }
   return { candidates, allReposFailed, rateLimitHit };
 }
@@ -37041,7 +37546,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(MODULE8, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(", ")}`);
+    debug(MODULE9, `[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);
@@ -37052,7 +37557,7 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
     return excludedRepoSets.every((s) => !s.has(repoFullName));
   }).slice(0, remainingNeeded * 2);
   if (itemsToVet.length === 0) {
-    debug(MODULE8, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
+    debug(MODULE9, `[${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");
@@ -37064,13 +37569,13 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
   });
   const starFilteredCount = results.length - starFiltered.length;
   if (starFilteredCount > 0) {
-    debug(MODULE8, `[STAR_FILTER] Filtered ${starFilteredCount} ${phaseLabel} candidates below ${minStars} stars`);
+    debug(MODULE9, `[STAR_FILTER] Filtered ${starFilteredCount} ${phaseLabel} candidates below ${minStars} stars`);
   }
   return { candidates: starFiltered, allVetFailed, rateLimitHit };
 }
 
 // ../core/dist/core/issue-discovery.js
-var MODULE9 = "issue-discovery";
+var MODULE10 = "issue-discovery";
 var LOW_BUDGET_THRESHOLD = 20;
 var CRITICAL_BUDGET_THRESHOLD = 10;
 function buildIssueFilter(config2) {
@@ -37103,9 +37608,9 @@ function buildIssueFilter(config2) {
   };
 }
 async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
-  info(MODULE9, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter)...`);
+  info(MODULE10, `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(MODULE9, `Found ${candidates.length} candidates from merged-PR repos`);
+  info(MODULE10, `Found ${candidates.length} candidates from merged-PR repos`);
   return {
     candidates,
     error: allReposFailed ? "All merged-PR repo fetches failed" : null,
@@ -37113,11 +37618,11 @@ async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
   };
 }
 async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssues) {
-  info(MODULE9, `Phase 1: Searching issues in ${repos.length} starred repos...`);
+  info(MODULE10, `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(MODULE9, `Found ${candidates.length} candidates from starred repos`);
+  info(MODULE10, `Found ${candidates.length} candidates from starred repos`);
   return {
     candidates,
     error: allReposFailed ? "All starred repo fetches failed" : null,
@@ -37125,14 +37630,14 @@ async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssue
   };
 }
 async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQualifiers, maxResults, minStars, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues) {
-  info(MODULE9, "Phase 2: General issue search...");
+  info(MODULE10, "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(MODULE9, `Scope "${scope}" has no labels, skipping tier`);
+        warn(MODULE10, `Scope "${scope}" has no labels, skipping tier`);
         continue;
       }
       tierLabelGroups.push({ tier: scope, tierLabels: scopeLabels });
@@ -37152,7 +37657,7 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
   for (const { tier, tierLabels } of tierLabelGroups) {
     try {
       const allItems = await searchWithChunkedLabels(octokit, tierLabels, 0, (labelQ) => `${baseQualifiers} ${labelQ}`.replace(/  +/g, " ").trim(), budgetPerTier * 3);
-      info(MODULE9, `Phase 2 [${tier}]: processing ${allItems.length} items...`);
+      info(MODULE10, `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)
@@ -37163,7 +37668,7 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
       if (vetRateLimitHit) {
         rateLimitHit = true;
       }
-      info(MODULE9, `Found ${tierCandidates.length} candidates from ${tier} tier`);
+      info(MODULE10, `Found ${tierCandidates.length} candidates from ${tier} tier`);
     } catch (err) {
       if (getHttpStatusCode(err) === 401)
         throw err;
@@ -37172,13 +37677,13 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
       if (isRateLimitError(err)) {
         rateLimitHit = true;
       }
-      warn(MODULE9, `Error in ${tier} tier search: ${errMsg}`);
+      warn(MODULE10, `Error in ${tier} tier search: ${errMsg}`);
       tierResults.push([]);
     }
   }
   const interleaved = interleaveArrays(tierResults);
   if (interleaved.length === 0 && error48) {
-    warn(MODULE9, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error48}`);
+    warn(MODULE10, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error48}`);
   }
   return {
     candidates: interleaved.slice(0, maxResults),
@@ -37187,17 +37692,17 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, baseQual
   };
 }
 async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues) {
-  info(MODULE9, "Phase 3: Searching actively maintained repos...");
+  info(MODULE10, "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(MODULE9, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
+    info(MODULE10, `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(MODULE9, `Found ${candidates.length} candidates from maintained-repo REST search`);
+          info(MODULE10, `Found ${candidates.length} candidates from maintained-repo REST search`);
           return {
             candidates,
             error: allVetFailed ? "all vetting failed" : null,
@@ -37207,11 +37712,11 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       } catch (error48) {
         if (getHttpStatusCode(error48) === 401)
           throw error48;
-        warn(MODULE9, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error48));
+        warn(MODULE10, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error48));
       }
     }
   }
-  info(MODULE9, "Phase 3: Falling back to Search API...");
+  info(MODULE10, "Phase 3: Falling back to Search API...");
   const thirtyDaysAgo = /* @__PURE__ */ new Date();
   thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
   const pushedSince = thirtyDaysAgo.toISOString().split("T")[0];
@@ -37225,17 +37730,19 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       order: "desc",
       per_page: maxResults * 3
     });
-    info(MODULE9, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
+    info(MODULE10, `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(MODULE9, `Found ${candidates.length} candidates from maintained-repo search`);
+    info(MODULE10, `Found ${candidates.length} candidates from maintained-repo search`);
     return {
       candidates,
       error: allVetFailed ? "all vetting failed" : null,
       rateLimitHit: vetRateLimitHit
     };
   } catch (error48) {
+    if (getHttpStatusCode(error48) === 401)
+      throw error48;
     const errMsg = errorMessage(error48);
-    warn(MODULE9, `Error in maintained-repo search: ${errMsg}`);
+    warn(MODULE10, `Error in maintained-repo search: ${errMsg}`);
     return {
       candidates: [],
       error: errMsg,
@@ -37319,24 +37826,25 @@ 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(MODULE9, this.rateLimitWarning);
+        warn(MODULE10, this.rateLimitWarning);
       }
       if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
-        info(MODULE9, `Search budget critical (${searchBudget} remaining) \u2014 running only Phase 0`);
+        info(MODULE10, `Search budget critical (${searchBudget} remaining) \u2014 running only Phase 0`);
       } else if (searchBudget < LOW_BUDGET_THRESHOLD) {
-        info(MODULE9, `Search budget low (${searchBudget} remaining) \u2014 skipping heavy phases (2, 3)`);
+        info(MODULE10, `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(MODULE9, "Could not check rate limit \u2014 using conservative budget, skipping heavy phases:", errorMessage(error48));
+      warn(MODULE10, "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.";
       return { candidates: [], strategiesUsed: [] };
     }
     const mergedPRRepos = this.stateReader.getReposWithMergedPRs();
+    const openPRRepos = this.stateReader.getReposWithOpenPRs();
     const starredRepos = this.getStarredRepos();
     const starredRepoSet = new Set(starredRepos);
     const lowScoringRepos = new Set(this.deriveLowScoringRepos(config2.minRepoScoreThreshold));
@@ -37345,7 +37853,7 @@ var IssueDiscovery = class {
     const baseQualifiers = `is:issue is:open ${langQuery} no:assignee`.replace(/  +/g, " ").trim();
     const aiBlocklisted = new Set(config2.aiPolicyBlocklist);
     if (aiBlocklisted.size > 0) {
-      debug(MODULE9, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
+      debug(MODULE10, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
     }
     const filterIssues = buildIssueFilter({
       excludedRepos: new Set(config2.excludeRepos),
@@ -37357,7 +37865,16 @@ var IssueDiscovery = class {
       now: /* @__PURE__ */ new Date(),
       includeDocIssues: config2.includeDocIssues ?? true
     });
-    const phase0Repos = mergedPRRepos.slice(0, 10);
+    const seenPhase0 = /* @__PURE__ */ new Set();
+    const phase0Repos = [];
+    for (const repo of [...mergedPRRepos, ...openPRRepos]) {
+      if (seenPhase0.has(repo))
+        continue;
+      seenPhase0.add(repo);
+      phase0Repos.push(repo);
+      if (phase0Repos.length >= 10)
+        break;
+    }
     const phase0RepoSet = new Set(phase0Repos);
     if (phase0Repos.length > 0 && enabledStrategies.has("merged")) {
       const remaining = maxResults - allCandidates.length;
@@ -37372,7 +37889,7 @@ var IssueDiscovery = class {
     }
     if (allCandidates.length < maxResults && starredRepos.length > 0 && searchBudget >= CRITICAL_BUDGET_THRESHOLD && enabledStrategies.has("starred")) {
       if (interPhaseDelay > 0) {
-        info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
         await sleep(interPhaseDelay);
       }
       const reposToSearch = starredRepos.filter((r) => !phase0RepoSet.has(r));
@@ -37392,17 +37909,17 @@ var IssueDiscovery = class {
     const skipThreshold = config2.skipBroadWhenSufficientResults ?? 15;
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("broad")) {
       if (skipThreshold > 0 && allCandidates.length >= skipThreshold) {
-        info(MODULE9, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
+        info(MODULE10, `Skipping broad search: already found ${allCandidates.length} candidates (threshold: ${skipThreshold})`);
       } else {
         if (interPhaseDelay > 0) {
-          info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+          info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
           await sleep(interPhaseDelay);
         }
         if (allCandidates.length > 0 && broadDelay > 0) {
-          info(MODULE9, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
+          info(MODULE10, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
           await sleep(broadDelay);
         } else if (allCandidates.length === 0) {
-          info(MODULE9, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
+          info(MODULE10, `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, baseQualifiers, remaining, minStars, phase0RepoSet, starredRepoSet, allCandidates, filterIssues);
@@ -37415,7 +37932,7 @@ var IssueDiscovery = class {
     }
     if (allCandidates.length < maxResults && searchBudget >= LOW_BUDGET_THRESHOLD && enabledStrategies.has("maintained")) {
       if (interPhaseDelay > 0) {
-        info(MODULE9, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        info(MODULE10, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
         await sleep(interPhaseDelay);
       }
       const remaining = maxResults - allCandidates.length;
@@ -37466,7 +37983,7 @@ var IssueDiscovery = class {
       return b.viabilityScore - a.viabilityScore;
     });
     const capped = applyPerRepoCap(allCandidates, 2);
-    info(MODULE9, `Search complete: ${tracker.getTotalCalls()} Search API calls used, ${capped.length} candidates returned`);
+    info(MODULE10, `Search complete: ${tracker.getTotalCalls()} Search API calls used, ${capped.length} candidates returned`);
     return { candidates: capped.slice(0, maxResults), strategiesUsed };
   }
   /**
@@ -37498,15 +38015,375 @@ var IssueDiscovery = class {
   }
 };
 
+// ../core/dist/core/roadmap.js
+var MODULE11 = "roadmap";
+var CACHE_TTL_MS2 = 60 * 60 * 1e3;
+var ROADMAP_PATHS = [
+  "ROADMAP.md",
+  "docs/ROADMAP.md",
+  ".github/ROADMAP.md",
+  "Roadmap.md",
+  "roadmap.md"
+];
+var roadmapCache = /* @__PURE__ */ new Map();
+function pruneCache2() {
+  const cutoff = Date.now() - CACHE_TTL_MS2;
+  for (const [key, value] of roadmapCache.entries()) {
+    if (value.fetchedAt < cutoff)
+      roadmapCache.delete(key);
+  }
+}
+function parseRoadmapIssueRefs(content, owner, repo) {
+  const refs = /* @__PURE__ */ new Set();
+  const ownerRepoLower = `${owner}/${repo}`.toLowerCase();
+  const escape2 = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const fullRefPattern = new RegExp(`\\b${escape2(owner)}/${escape2(repo)}#(\\d+)\\b`, "gi");
+  for (const m of content.matchAll(fullRefPattern)) {
+    const n = Number.parseInt(m[1], 10);
+    if (n > 0)
+      refs.add(n);
+  }
+  const fullRefStripPattern = /\b[\w.-]+\/[\w.-]+#\d+\b/gi;
+  for (const line of content.split("\n")) {
+    if (/^\s*#+\s/.test(line))
+      continue;
+    const stripped = line.replace(fullRefStripPattern, "");
+    for (const m of stripped.matchAll(/(?:^|[^&\w])#(\d+)\b/g)) {
+      const n = Number.parseInt(m[1], 10);
+      if (n > 0)
+        refs.add(n);
+    }
+  }
+  const urlPattern = /https?:\/\/github\.com\/([\w.-]+\/[\w.-]+)\/issues\/(\d+)/gi;
+  for (const m of content.matchAll(urlPattern)) {
+    if (m[1].toLowerCase() === ownerRepoLower) {
+      const n = Number.parseInt(m[2], 10);
+      if (n > 0)
+        refs.add(n);
+    }
+  }
+  return refs;
+}
+async function fetchRoadmapIssueRefs(octokit, owner, repo) {
+  const cacheKey = `${owner}/${repo}`.toLowerCase();
+  const cached2 = roadmapCache.get(cacheKey);
+  if (cached2 && Date.now() - cached2.fetchedAt < CACHE_TTL_MS2) {
+    return cached2.refs;
+  }
+  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 empty = /* @__PURE__ */ new Set();
+  roadmapCache.set(cacheKey, { refs: empty, fetchedAt: Date.now() });
+  pruneCache2();
+  return empty;
+}
+
+// ../core/dist/core/feature-discovery.js
+var MODULE12 = "feature-discovery";
+var INTER_REPO_DELAY_MS = 2e3;
+var MIN_VIABILITY_SCORE = 40;
+var ANCHOR_THRESHOLD = 3;
+var DEFAULT_SPLIT_RATIO = 0.6;
+function resolveAnchorRepos(repoScores, threshold = ANCHOR_THRESHOLD) {
+  return Object.values(repoScores).filter((rs) => rs.mergedPRCount >= threshold).sort((a, b) => b.mergedPRCount - a.mergedPRCount).map((rs) => rs.repo);
+}
+var BIGGER_BET_LABELS = /* @__PURE__ */ new Set([
+  "roadmap",
+  "accepted-rfc",
+  "proposal"
+]);
+function classifyHorizon(input) {
+  if (input.hasMilestone || input.isOnRoadmap)
+    return "bigger-bet";
+  for (const label of input.labels) {
+    if (BIGGER_BET_LABELS.has(label.toLowerCase()))
+      return "bigger-bet";
+  }
+  return "quick-win";
+}
+function splitByHorizon(candidates, count, ratio = DEFAULT_SPLIT_RATIO) {
+  const allQuick = candidates.filter((c) => c.horizon === "quick-win").sort((a, b) => b.viabilityScore - a.viabilityScore);
+  const allBigger = candidates.filter((c) => c.horizon === "bigger-bet").sort((a, b) => b.viabilityScore - a.viabilityScore);
+  const targetQuick = Math.round(count * ratio);
+  const targetBigger = count - targetQuick;
+  const quickTaken = Math.min(allQuick.length, targetQuick);
+  const biggerTaken = Math.min(allBigger.length, targetBigger);
+  let quickFinal = quickTaken;
+  let biggerFinal = biggerTaken;
+  const quickDeficit = targetQuick - quickTaken;
+  const biggerDeficit = targetBigger - biggerTaken;
+  if (quickDeficit > 0) {
+    biggerFinal = Math.min(allBigger.length, biggerFinal + quickDeficit);
+  }
+  if (biggerDeficit > 0) {
+    quickFinal = Math.min(allQuick.length, quickFinal + biggerDeficit);
+  }
+  return {
+    quickWins: allQuick.slice(0, quickFinal),
+    biggerBets: allBigger.slice(0, biggerFinal)
+  };
+}
+var FEATURE_LABELS = [
+  "enhancement",
+  "feature",
+  "feature-request",
+  "proposal",
+  "roadmap",
+  "accepted-rfc"
+];
+var FEATURE_EXCLUSION_LABELS = /* @__PURE__ */ new Set([
+  "good first issue",
+  "bug",
+  "documentation"
+]);
+var WONTFIX_NO_CONTRIBUTOR_LABELS = /* @__PURE__ */ new Set([
+  "help wanted",
+  "contributions welcome",
+  "up-for-grabs",
+  "bounty",
+  "pinned",
+  "unmaintained"
+]);
+var WONTFIX_MIN_AGE_DAYS = 60;
+function detectWontfixNoContributor(input) {
+  const matched = input.labels.some((l) => WONTFIX_NO_CONTRIBUTOR_LABELS.has(l.toLowerCase()));
+  if (!matched)
+    return false;
+  const created = new Date(input.createdAt);
+  if (Number.isNaN(created.getTime()))
+    return false;
+  const now = input.now ?? /* @__PURE__ */ new Date();
+  const ageDays = (now.getTime() - created.getTime()) / (1e3 * 60 * 60 * 24);
+  return ageDays >= (input.minAgeDays ?? WONTFIX_MIN_AGE_DAYS);
+}
+var NO_ANCHORS_MESSAGE = "No anchor repos yet (need 3+ merged PRs in a repo). Try `scout search` to build relationships first.";
+var NO_RESULTS_MESSAGE = "No open feature opportunities in your anchor repos right now. Check back next week, or try `scout search` for fix-mode work.";
+function extractLabels(item) {
+  if (!Array.isArray(item.labels))
+    return [];
+  return item.labels.map((l) => typeof l === "string" ? l : l?.name).filter((s) => typeof s === "string");
+}
+function isFeatureIssue(item) {
+  const labels = extractLabels(item).map((l) => l.toLowerCase());
+  if (labels.length === 0)
+    return false;
+  if (labels.some((l) => FEATURE_EXCLUSION_LABELS.has(l)))
+    return false;
+  return labels.some((l) => FEATURE_LABELS.includes(l));
+}
+async function discoverFeatures(opts) {
+  const anchorRepos = resolveAnchorRepos(opts.repoScores, opts.anchorThreshold);
+  if (anchorRepos.length === 0) {
+    return {
+      quickWins: [],
+      biggerBets: [],
+      anchorRepos: [],
+      message: NO_ANCHORS_MESSAGE
+    };
+  }
+  const candidates = [];
+  for (let i = 0; i < anchorRepos.length; i++) {
+    if (i > 0)
+      await sleep(INTER_REPO_DELAY_MS);
+    const [owner, repo] = anchorRepos[i].split("/");
+    let response;
+    let roadmapRefs;
+    try {
+      const [listResp, refs] = await Promise.all([
+        opts.octokit.issues.listForRepo({
+          owner,
+          repo,
+          state: "open",
+          sort: "updated",
+          direction: "desc",
+          per_page: 20
+        }),
+        fetchRoadmapIssueRefs(opts.octokit, owner, repo)
+      ]);
+      response = listResp;
+      roadmapRefs = refs;
+    } catch (err) {
+      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+        throw 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 passing = candidates.filter((c) => c.viabilityScore >= MIN_VIABILITY_SCORE);
+  const split = splitByHorizon(passing, opts.count, opts.splitRatio);
+  const total = split.quickWins.length + split.biggerBets.length;
+  return {
+    ...split,
+    anchorRepos,
+    message: total === 0 ? NO_RESULTS_MESSAGE : null
+  };
+}
+var NO_BROAD_RESULTS_MESSAGE = "No open feature opportunities matched your filters. Try widening your language preferences in `scout config`.";
+var DEFAULT_BROAD_MAX_TO_VET = 30;
+function buildBroadFeatureSearchQuery(opts) {
+  const parts = ["is:issue", "is:open", "no:assignee"];
+  const labelClause = FEATURE_LABELS.map((l) => `label:"${l}"`).join(" OR ");
+  parts.push(`(${labelClause})`);
+  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})`);
+  }
+  for (const repo of opts.excludeRepos ?? []) {
+    parts.push(`-repo:${repo}`);
+  }
+  for (const org of opts.excludeOrgs ?? []) {
+    parts.push(`-user:${org}`);
+  }
+  return parts.join(" ");
+}
+async function discoverFeaturesBroad(opts) {
+  const query = buildBroadFeatureSearchQuery({
+    languages: opts.languages,
+    excludeRepos: opts.excludeRepos,
+    excludeOrgs: opts.excludeOrgs
+  });
+  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));
+  } catch (err) {
+    if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+      throw err;
+    warn(MODULE12, `broad feature search failed: ${errorMessage(err)}`);
+    return {
+      quickWins: [],
+      biggerBets: [],
+      anchorRepos: [],
+      message: NO_BROAD_RESULTS_MESSAGE
+    };
+  }
+  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 passing = candidates.filter((c) => c.viabilityScore >= MIN_VIABILITY_SCORE);
+  const split = splitByHorizon(passing, opts.count, opts.splitRatio);
+  const total = split.quickWins.length + split.biggerBets.length;
+  return {
+    ...split,
+    anchorRepos: [],
+    message: total === 0 ? NO_BROAD_RESULTS_MESSAGE : null
+  };
+}
+
 // ../core/dist/core/gist-state-store.js
 var fs3 = __toESM(require("fs"), 1);
 var path3 = __toESM(require("path"), 1);
-var MODULE10 = "gist-state";
+var MODULE13 = "gist-state";
 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;
+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) {
+    const code = err.code;
+    if (code === "ECONNREFUSED" || code === "ENOTFOUND" || code === "ETIMEDOUT" || code === "ECONNRESET" || code === "EAI_AGAIN") {
+      return "network";
+    }
+  }
+  if (err instanceof Error && err.message.toLowerCase().includes("fetch failed")) {
+    return "network";
+  }
+  return "unknown";
+}
 function getGistIdPath() {
   return path3.join(getDataDir(), GIST_ID_FILE);
 }
@@ -37527,8 +38404,10 @@ var GistStateStore = class {
     try {
       return await this.bootstrapFromApi();
     } catch (err) {
-      warn(MODULE10, `API bootstrap failed: ${errorMessage(err)}`);
-      return this.bootstrapFromCache();
+      if (getHttpStatusCode(err) === 401)
+        throw err;
+      warn(MODULE13, `API bootstrap failed: ${errorMessage(err)}`);
+      return this.bootstrapFromCache(classifyDegradedReason(err));
     }
   }
   /**
@@ -37537,12 +38416,12 @@ var GistStateStore = class {
   async push(state) {
     this.writeCache(state);
     if (!this.gistId) {
-      warn(MODULE10, "No gist ID \u2014 cannot push");
+      warn(MODULE13, "No gist ID \u2014 cannot push");
       return false;
     }
     const json2 = JSON.stringify(state, null, 2);
     if (json2.length > 9e5) {
-      warn(MODULE10, `State too large for gist (${Math.round(json2.length / 1024)}KB). Consider clearing old results with 'oss-scout results clear'.`);
+      warn(MODULE13, `State too large for gist (${Math.round(json2.length / 1024)}KB). Consider clearing old results with 'oss-scout results clear'.`);
       return false;
     }
     try {
@@ -37552,10 +38431,12 @@ var GistStateStore = class {
           [GIST_FILENAME]: { content: json2 }
         }
       });
-      debug(MODULE10, "State pushed to gist");
+      debug(MODULE13, "State pushed to gist");
       return true;
     } catch (err) {
-      warn(MODULE10, `Failed to push: ${errorMessage(err)}`);
+      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+        throw err;
+      warn(MODULE13, `Failed to push: ${errorMessage(err)}`);
       return false;
     }
   }
@@ -37572,7 +38453,9 @@ var GistStateStore = class {
       }
       return state;
     } catch (err) {
-      warn(MODULE10, `Failed to pull: ${errorMessage(err)}`);
+      if (getHttpStatusCode(err) === 401 || isRateLimitError(err))
+        throw err;
+      warn(MODULE13, `Failed to pull: ${errorMessage(err)}`);
       return null;
     }
   }
@@ -37584,7 +38467,7 @@ var GistStateStore = class {
   async bootstrapFromApi() {
     const cachedId = this.readCachedGistId();
     if (cachedId) {
-      debug(MODULE10, `Trying cached gist ID: ${cachedId}`);
+      debug(MODULE13, `Trying cached gist ID: ${cachedId}`);
       try {
         const state = await this.fetchGistState(cachedId);
         if (state) {
@@ -37593,13 +38476,15 @@ var GistStateStore = class {
           return { gistId: cachedId, state, created: false };
         }
       } catch (err) {
-        debug(MODULE10, `Cached gist ID invalid: ${errorMessage(err)}`);
+        if (getHttpStatusCode(err) !== 404)
+          throw err;
+        debug(MODULE13, `Cached gist gone (404): ${errorMessage(err)}`);
       }
-      debug(MODULE10, "Cached gist ID invalid, searching...");
+      debug(MODULE13, "Cached gist ID invalid, searching...");
     }
     const foundId = await this.searchForGist();
     if (foundId) {
-      debug(MODULE10, `Found gist via search: ${foundId}`);
+      debug(MODULE13, `Found gist via search: ${foundId}`);
       this.saveGistId(foundId);
       this.gistId = foundId;
       const state = await this.fetchGistState(foundId);
@@ -37607,10 +38492,10 @@ var GistStateStore = class {
         this.writeCache(state);
         return { gistId: foundId, state, created: false };
       }
-      warn(MODULE10, `Found existing gist ${foundId} but content failed validation. Using local cache to avoid data loss.`);
-      return this.bootstrapFromCache();
+      warn(MODULE13, `Found existing gist ${foundId} but content failed validation. Using local cache to avoid data loss.`);
+      return this.bootstrapFromCache("unknown");
     }
-    debug(MODULE10, "No existing gist found, creating new one");
+    debug(MODULE13, "No existing gist found, creating new one");
     const freshState = ScoutStateSchema.parse({ version: 1 });
     const newId = await this.createGist(freshState);
     this.saveGistId(newId);
@@ -37618,10 +38503,10 @@ var GistStateStore = class {
     this.writeCache(freshState);
     return { gistId: newId, state: freshState, created: true };
   }
-  bootstrapFromCache() {
+  bootstrapFromCache(reason) {
     const cached2 = this.readCache();
     if (cached2) {
-      debug(MODULE10, "Bootstrapped from local cache (degraded mode)");
+      debug(MODULE13, "Bootstrapped from local cache (degraded mode)");
       const cachedId = this.readCachedGistId();
       if (cachedId)
         this.gistId = cachedId;
@@ -37629,12 +38514,19 @@ var GistStateStore = class {
         gistId: cachedId ?? "",
         state: cached2,
         created: false,
-        degraded: true
+        degraded: true,
+        degradedReason: reason
       };
     }
-    debug(MODULE10, "No cache available, using fresh state (degraded mode)");
+    debug(MODULE13, "No cache available, using fresh state (degraded mode)");
     const fresh = ScoutStateSchema.parse({ version: 1 });
-    return { gistId: "", state: fresh, created: false, degraded: true };
+    return {
+      gistId: "",
+      state: fresh,
+      created: false,
+      degraded: true,
+      degradedReason: reason
+    };
   }
   // ── Gist API operations ──────────────────────────────────────────────
   async fetchGistState(gistId) {
@@ -37646,7 +38538,7 @@ var GistStateStore = class {
       const parsed = JSON.parse(file2.content);
       return ScoutStateSchema.parse(parsed);
     } catch (err) {
-      warn(MODULE10, `Gist content failed validation: ${errorMessage(err)}`);
+      warn(MODULE13, `Gist content failed validation: ${errorMessage(err)}`);
       return null;
     }
   }
@@ -37682,7 +38574,7 @@ var GistStateStore = class {
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") {
-        warn(MODULE10, `Failed to read cached gist ID: ${errorMessage(err)}`);
+        warn(MODULE13, `Failed to read cached gist ID: ${errorMessage(err)}`);
       }
       return null;
     }
@@ -37697,7 +38589,7 @@ var GistStateStore = class {
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") {
-        warn(MODULE10, `Failed to read state cache: ${errorMessage(err)}`);
+        warn(MODULE13, `Failed to read state cache: ${errorMessage(err)}`);
       }
       return null;
     }
@@ -37708,7 +38600,7 @@ var GistStateStore = class {
         mode: 384
       });
     } catch (err) {
-      warn(MODULE10, `Failed to write cache: ${errorMessage(err)}`);
+      warn(MODULE13, `Failed to write cache: ${errorMessage(err)}`);
     }
   }
 };
@@ -37721,6 +38613,7 @@ function mergeStates(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 ?? []),
     lastSearchAt: pickFresherTimestamp(local.lastSearchAt, remote.lastSearchAt),
@@ -37796,7 +38689,7 @@ function pickFresherTimestamp(a, b) {
 // ../core/dist/core/local-state.js
 var fs4 = __toESM(require("fs"), 1);
 var path4 = __toESM(require("path"), 1);
-var MODULE11 = "local-state";
+var MODULE14 = "local-state";
 function getStatePath() {
   return path4.join(getDataDir(), "state.json");
 }
@@ -37810,19 +38703,33 @@ function loadLocalState() {
     if (code === "ENOENT") {
       return ScoutStateSchema.parse({ version: 1 });
     }
-    warn(MODULE11, `Failed to load state from ${statePath}: ${errorMessage(err)}. Using defaults.`);
+    warn(MODULE14, `Failed to load state from ${statePath}: ${errorMessage(err)}. Using defaults.`);
     try {
       const backupPath = `${statePath}.corrupt.${Date.now()}`;
       fs4.copyFileSync(statePath, backupPath);
-      warn(MODULE11, `Corrupt state backed up to ${backupPath}`);
+      warn(MODULE14, `Corrupt state backed up to ${backupPath}`);
     } catch (backupErr) {
-      warn(MODULE11, `Failed to back up corrupt state: ${errorMessage(backupErr)}`);
+      warn(MODULE14, `Failed to back up corrupt state: ${errorMessage(backupErr)}`);
     }
     return ScoutStateSchema.parse({ version: 1 });
   }
 }
 
 // ../core/dist/scout.js
+function offlineModeMessage(reason) {
+  const tail = "Changes will only be saved locally.";
+  switch (reason) {
+    case "rate_limit":
+      return `Gist sync unavailable \u2014 GitHub API rate limit exceeded. ${tail} Try again after the rate limit resets.`;
+    case "network":
+      return `Gist sync unavailable \u2014 could not reach GitHub. ${tail} Check your network connection.`;
+    case "server":
+      return `Gist sync unavailable \u2014 GitHub returned a server error. ${tail} Try again later.`;
+    case "unknown":
+    case void 0:
+      return `Gist sync unavailable \u2014 running in offline mode. ${tail}`;
+  }
+}
 function toGistOctokit(octokit) {
   return {
     gists: {
@@ -37869,7 +38776,7 @@ async function createScout(config2) {
     gistStore = new GistStateStore(toGistOctokit(getOctokit(config2.githubToken)));
     const result = await gistStore.bootstrap();
     if (result.degraded) {
-      warn("scout", "Gist sync unavailable \u2014 running in offline mode. Changes will only be saved locally.");
+      warn("scout", offlineModeMessage(result.degradedReason));
     }
     const localState = loadLocalState();
     state = mergeStates(localState, result.state);
@@ -37924,6 +38831,45 @@ var OssScout = class {
     const discovery = new IssueDiscovery(this.githubToken, this.state.preferences, this);
     return discovery.vetIssue(issueUrl);
   }
+  /**
+   * `scout features` — surfaces feature-scoped contribution opportunities
+   * in repos where the user has 3+ merged PRs (configurable via
+   * `featuresAnchorThreshold`), ranked into separate "quick wins" and
+   * "bigger bets" buckets (split via `featuresSplitRatio`).
+   *
+   * Per-call `anchorThreshold` and `splitRatio` overrides take precedence
+   * over the persisted preferences.
+   *
+   * When `broad` is true (#100), bypasses anchor resolution and runs a
+   * cross-repo GitHub Search query for first-touch contributors who
+   * haven't yet built repo relationships. Filters by user language
+   * preferences and excluded repos/orgs.
+   */
+  async features(options) {
+    const count = options?.count ?? 10;
+    const octokit = getOctokit(this.githubToken);
+    const vetter = new IssueVetter(octokit, this);
+    const result = options?.broad ? await discoverFeaturesBroad({
+      octokit,
+      vetter,
+      count,
+      languages: this.state.preferences.languages,
+      excludeRepos: this.state.preferences.excludeRepos,
+      excludeOrgs: this.state.preferences.excludeOrgs,
+      splitRatio: options?.splitRatio ?? this.state.preferences.featuresSplitRatio
+    }) : await discoverFeatures({
+      octokit,
+      vetter,
+      repoScores: this.state.repoScores ?? {},
+      count,
+      anchorThreshold: options?.anchorThreshold ?? this.state.preferences.featuresAnchorThreshold,
+      splitRatio: options?.splitRatio ?? this.state.preferences.featuresSplitRatio
+    });
+    this.saveResults([...result.quickWins, ...result.biggerBets]);
+    this.state.lastSearchAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.dirty = true;
+    return result;
+  }
   // ── Batch Vetting ───────────────────────────────────────────────────
   /**
    * Re-vet all saved results with bounded concurrency.
@@ -37935,7 +38881,10 @@ var OssScout = class {
     const concurrency = options?.concurrency ?? 5;
     const results = [];
     const pending = /* @__PURE__ */ new Map();
+    let firstHardError = null;
     for (const item of saved) {
+      if (firstHardError)
+        break;
       const task = this.vetIssue(item.issueUrl).then((candidate) => {
         results.push({
           issueUrl: item.issueUrl,
@@ -37947,15 +38896,19 @@ var OssScout = class {
           viabilityScore: candidate.viabilityScore
         });
       }).catch((error48) => {
-        const msg = error48 instanceof Error ? error48.message : String(error48);
-        const isGone = msg.includes("Not Found") || msg.includes("410");
+        if (getHttpStatusCode(error48) === 401 || isRateLimitError(error48)) {
+          firstHardError ??= error48;
+          return;
+        }
+        const status = getHttpStatusCode(error48);
+        const isGone = status === 404 || status === 410;
         results.push({
           issueUrl: item.issueUrl,
           repo: item.repo,
           number: item.number,
           title: item.title,
           status: isGone ? "closed" : "error",
-          errorMessage: msg
+          errorMessage: errorMessage(error48)
         });
       }).finally(() => {
         pending.delete(item.issueUrl);
@@ -37966,6 +38919,12 @@ var OssScout = class {
       }
     }
     await Promise.allSettled(pending.values());
+    if (firstHardError) {
+      if (results.length > 0) {
+        warn("scout", `vetList aborted mid-batch after ${results.length} result(s) \u2014 discarding partial results due to auth/rate-limit failure`);
+      }
+      throw firstHardError;
+    }
     const summary = {
       total: results.length,
       stillAvailable: results.filter((r) => r.status === "still_available").length,
@@ -38003,6 +38962,16 @@ var OssScout = class {
     }
     return [...repoCounts.entries()].sort((a, b) => b[1] - a[1]).map(([repo]) => repo);
   }
+  getReposWithOpenPRs() {
+    const repoCounts = /* @__PURE__ */ new Map();
+    for (const pr of this.state.openPRs ?? []) {
+      const repo = extractRepoFromUrl(pr.url);
+      if (repo) {
+        repoCounts.set(repo, (repoCounts.get(repo) ?? 0) + 1);
+      }
+    }
+    return [...repoCounts.entries()].sort((a, b) => b[1] - a[1]).map(([repo]) => repo);
+  }
   getStarredRepos() {
     return this.state.starredRepos;
   }
@@ -38013,6 +38982,16 @@ var OssScout = class {
     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.
+   */
+  getSLMTriageConfig() {
+    return {
+      model: this.state.preferences.slmTriageModel ?? "",
+      host: this.state.preferences.slmTriageHost ?? ""
+    };
+  }
   /** Get current preferences (read-only). */
   getPreferences() {
     return this.state.preferences;
@@ -38051,6 +39030,20 @@ var OssScout = class {
     this.updateRepoScoreFromPRs(pr.repo);
     this.dirty = true;
   }
+  /**
+   * Record that a PR is currently open in this repo.
+   * Open PRs signal active engagement even when nothing is merged yet.
+   */
+  recordOpenPR(pr) {
+    const existing = this.state.openPRs ?? [];
+    if (existing.some((p) => p.url === pr.url))
+      return;
+    this.state.openPRs = [
+      ...existing,
+      { url: pr.url, title: pr.title, openedAt: pr.openedAt }
+    ];
+    this.dirty = true;
+  }
   /**
    * Update repo score with observed signals.
    */
@@ -38117,7 +39110,8 @@ var OssScout = class {
         searchPriority: c.searchPriority,
         firstSeenAt: prev?.firstSeenAt ?? now,
         lastSeenAt: now,
-        lastScore: c.viabilityScore
+        lastScore: c.viabilityScore,
+        horizon: "horizon" in c ? c.horizon : void 0
       });
     }
     this.state.savedResults = [...existing.values()];
@@ -38302,6 +39296,37 @@ function registerTools(server, scout) {
       }
     }
   );
+  server.tool(
+    "scout-features",
+    "Surface feature-scoped contribution opportunities in repos where you have 3+ merged PRs",
+    {
+      maxResults: external_exports3.number().optional().describe("Maximum number of results to return (default 10)"),
+      anchorThreshold: external_exports3.number().int().min(1).max(50).optional().describe("Anchor threshold override (default 3)"),
+      splitRatio: external_exports3.number().min(0).max(1).optional().describe("Quick-wins/bigger-bets split ratio (default 0.6)")
+    },
+    async ({ maxResults, anchorThreshold, splitRatio }) => {
+      try {
+        const result = await withTimeout(
+          scout.features({
+            count: maxResults ?? 10,
+            anchorThreshold,
+            splitRatio
+          })
+        );
+        scout.saveResults([...result.quickWins, ...result.biggerBets]);
+        await scout.checkpoint();
+        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(
     "vet",
     "Vet a specific GitHub issue for contribution viability",
@@ -38435,7 +39460,9 @@ function registerTools(server, scout) {
     "minRepoScoreThreshold",
     "interPhaseDelayMs",
     "broadPhaseDelayMs",
-    "skipBroadWhenSufficientResults"
+    "skipBroadWhenSufficientResults",
+    "featuresAnchorThreshold",
+    "featuresSplitRatio"
   ]);
   const BOOLEAN_KEYS = /* @__PURE__ */ new Set(["includeDocIssues"]);
   server.tool(