@oss-scout/mcp 0.13.1 → 0.13.2

package/dist/mcp-server.bundle.cjs

@@ -42269,6 +42269,12 @@ function isAuthError(error62) {
   return status === 403 && !isRateLimitError(error62);
 }
 function isRateLimitError(error62) {
+  const e = error62;
+  for (const gqlErrors of [e?.errors, e?.data?.errors]) {
+    if (Array.isArray(gqlErrors) && gqlErrors.some((g) => g?.type === "RATE_LIMITED")) {
+      return true;
+    }
+  }
   const status = getHttpStatusCode(error62);
   if (status === 429)
     return true;
@@ -42622,7 +42628,8 @@ var SearchBudgetTracker = class {
         this.reservedCalls++;
         return;
       }
-      const waitUntil = oldestInWindow + SEARCH_WINDOW_MS;
+      const externalExhausted = this.knownRemaining - this.callsSinceReset - this.reservedCalls <= 0;
+      const waitUntil = externalExhausted && this.resetAt > Date.now() ? Math.min(oldestInWindow + SEARCH_WINDOW_MS, this.resetAt) : oldestInWindow + SEARCH_WINDOW_MS;
       const waitMs = waitUntil - Date.now();
       if (waitMs > 0) {
         debug(MODULE3, `Budget full (${this.callTimestamps.length}/${EFFECTIVE_BUDGET} in window), waiting ${waitMs}ms`);
@@ -42826,6 +42833,7 @@ var SavedCandidateSchema = external_exports.looseObject({
   lastStatus: external_exports.enum(["still_available", "claimed", "closed", "has_pr"]).optional()
 });
 var PersistenceModeSchema = external_exports.enum(["local", "gist"]);
+var ComplexIssuesModeSchema = external_exports.enum(["off", "warm"]);
 var ScoutPreferencesSchema = external_exports.looseObject({
   githubUsername: external_exports.string().default(""),
   languages: external_exports.array(external_exports.string()).default(["any"]),
@@ -42888,6 +42896,17 @@ var ScoutPreferencesSchema = external_exports.looseObject({
    * local network.
    */
   slmTriageHost: external_exports.string().default(""),
+  /**
+   * Surface issues that are not starter-shaped. "warm" unlocks them in repos
+   * where the user already has a merged PR, and nowhere else: there a PR
+   * that merely mentions the issue no longer counts as an existing PR (only
+   * one that closes it does), a maintainer-filed or triage-accepted issue
+   * passes the requirements check without code in its body, and a
+   * maintainer-filed issue is not dropped for a question-shaped or short
+   * title. Unlocked candidates carry `complexityUnlocked: true`. "off" (the
+   * default) keeps the same rules everywhere.
+   */
+  complexIssues: ComplexIssuesModeSchema.default("off"),
   /**
    * Minimum merged-PR count for a repo to qualify as an anchor in
    * `scout features` (#98). Lowering surfaces more anchors at the cost
@@ -42950,10 +42969,11 @@ var ScoutStateSchema = external_exports.looseObject({
    * consumer wraps at use time so a shrinking language list never needs
    * clamping here).
    *
-   * `phase0Offset`, `starredOffset` and `maintainedOffset` do the same for the
-   * repo lists those phases cap per run (#324, #333): each run searches the
-   * next window of the list instead of always the first N, so every
-   * contributed/starred repo gets searched within a few runs.
+   * `starredOffset` and `maintainedOffset` do the same for the repo lists
+   * those phases cap per run (#324, #333): each run searches the next window
+   * of the list instead of always the first N, so every starred repo gets
+   * searched within a few runs. `phase0Offset` is still advanced but no
+   * longer read: the merged phase reads every contributed repo each run.
    *
    * `strategyOffset` is the round-robin cursor (#336): a position in
    * CONCRETE_STRATEGIES. A search runs the first usable strategy from there,
@@ -43019,15 +43039,23 @@ function isDocOnlyIssue(item) {
     return false;
   return nonEmptyLabels.every((n) => DOC_ONLY_LABELS.has(n));
 }
+var MAINTAINER_ASSOCIATIONS = /* @__PURE__ */ new Set([
+  "OWNER",
+  "MEMBER",
+  "COLLABORATOR"
+]);
 var NON_ACTIONABLE_LABELS = /* @__PURE__ */ new Set(["question", "discussion", "support"]);
-function isNonActionableIssue(item) {
+var QUESTION_TITLE = /^(?:(?:how|why|what|when|where|which|who)\b|(?:is|are|does|do|can|could|should|would|will|has|have)\s+(?:i|we|you|it|this|that|these|those|the|a|an|any|anyone|someone|there|my|your|our)\b)/i;
+function isNonActionableIssue(item, opts = {}) {
   const labelNames = (item.labels ?? []).map((l) => (typeof l === "string" ? l : l.name || "").toLowerCase());
   if (labelNames.some((n) => NON_ACTIONABLE_LABELS.has(n)))
     return true;
+  if (opts.labelsOnly)
+    return false;
   const title = (item.title ?? "").trim();
   if (title.endsWith("?"))
     return true;
-  if (/^(how|why|what|when|where|which|who|is|are|does|do|can|could|should|would|will|has|have)\b/i.test(title))
+  if (QUESTION_TITLE.test(title))
     return true;
   return title.split(/\s+/).filter(Boolean).length < 3;
 }
@@ -43570,6 +43598,18 @@ function isNotModifiedError(err) {
   return getHttpStatusCode(err) === 304;
 }
 
+// ../core/dist/core/linked-pr.js
+var STALLED_PR_THRESHOLD_DAYS = 30;
+function isLinkedPRStalled(linkedPR, now = /* @__PURE__ */ new Date(), thresholdDays = STALLED_PR_THRESHOLD_DAYS) {
+  if (!linkedPR || linkedPR.state !== "open" || !linkedPR.updatedAt)
+    return false;
+  const updated = new Date(linkedPR.updatedAt);
+  if (Number.isNaN(updated.getTime()))
+    return false;
+  const ageDays = (now.getTime() - updated.getTime()) / (1e3 * 60 * 60 * 24);
+  return ageDays >= thresholdDays;
+}
+
 // ../core/dist/core/issue-eligibility.js
 function isLinkedPREvent(e) {
   return e.event === "cross-referenced" && !!e.source?.issue?.pull_request;
@@ -43605,10 +43645,25 @@ 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}`),
+  // "I'd like to investigate and fix this", "I'd love to tackle it".
+  new RegExp(String.raw`\bi\s*(?:'d|would) (?:like|love) to (?:\w+ and )?(?:fix|tackle|take on|pick up|implement) ${ISSUE_OBJECT}`),
   /\bi\s*(?:'m|am) on it\b/,
   /\bi\s*(?:'ll|will) submit a pr\b/,
   /\bassigned to me\b/
 ];
+var OFFER_SUBJECT = String.raw`(?:^\s*|\b(?:i\s*(?:'m|am|'d be|would be|'ll be|will be)|we\s*(?:'re|are|'d be|would be|'ll be|will be))\s+(?:(?:really|very|more than|absolutely|also)\s+)?)`;
+var OFFER_PATTERNS = [
+  new RegExp(String.raw`${OFFER_SUBJECT}(?:happy|glad|willing|keen) to (?:open|send|submit|make|put up|raise|contribute|write) (?:a |the |an )?(?:[\w-]+ ){0,2}(?:pr|pull request|patch|fix)\b`),
+  new RegExp(String.raw`${OFFER_SUBJECT}(?:happy|glad|willing|keen) to (?:have a go|take a stab)\b`),
+  /\bi can (?:send|open|submit|put up) (?:this |it )?(?:as )?(?:a |the )?(?:pr|pull request|patch|fix)\b/,
+  /\bi\s*(?:'ll|will) (?:open|send|put up|raise) a (?:pr|pull request)\b/,
+  /\bi\s*(?:'d|would) love to contribute (?:this|it|a fix|the fix)\b/,
+  /\bi plan to (?:make|send|submit|open) (?:a |the )?(?:[\w-]+ ){0,2}(?:pr|pull request|fix|change)\b/
+];
+var OFFER_VETO = /\bnot\b|n't\b|\bbut\b|\bunless\b/;
+function stripNonStatements(body) {
+  return body.replace(/<!--[\s\S]*?-->/g, " ").replace(/```[\s\S]*?```/g, " ").replace(/^\s*[-*] \[ \].*$/gm, " ").replace(/^\s*>.*$/gm, " ");
+}
 var GENERIC_WORKING_PATTERNS = [
   /\bworking on (?:this|it)\b/,
   /\bworking on a (?:fix|pr)\b/
@@ -43616,7 +43671,7 @@ var GENERIC_WORKING_PATTERNS = [
 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+/);
+  const clauses = stripNonStatements(body).toLowerCase().split(/(?<=[.!?])|\n+/);
   for (const clause of clauses) {
     if (PERMISSION_CLAIM_PATTERN.test(clause))
       return true;
@@ -43624,6 +43679,8 @@ function commentClaimsIssue(body) {
       continue;
     if (FIRST_PERSON_CLAIM_PATTERNS.some((p) => p.test(clause)))
       return true;
+    if (!OFFER_VETO.test(clause) && OFFER_PATTERNS.some((p) => p.test(clause)))
+      return true;
     if (NON_CLAIM_SUBJECTS.test(clause))
       continue;
     if (GENERIC_WORKING_PATTERNS.some((p) => p.test(clause)))
@@ -43631,8 +43688,67 @@ function commentClaimsIssue(body) {
   }
   return false;
 }
-async function checkNoExistingPR(octokit, owner, repo, issueNumber) {
+function toLinkedPR(pr) {
+  return {
+    number: pr.number,
+    // A deleted account has no login; the PR still counts.
+    author: pr.author?.login ?? "ghost",
+    state: pr.state === "OPEN" ? "open" : "closed",
+    merged: pr.state === "MERGED",
+    url: pr.url,
+    updatedAt: pr.updatedAt
+  };
+}
+var CLOSING_PR_RANK = { MERGED: 0, OPEN: 1, CLOSED: 2 };
+async function checkNoClosingPR(octokit, owner, repo, issueNumber, username) {
+  const data = await octokit.graphql(`query closingPRs($owner: String!, $repo: String!, $number: Int!) {
+      repository(owner: $owner, name: $repo) {
+        issue(number: $number) {
+          closedByPullRequestsReferences(first: 20, includeClosedPrs: true) {
+            nodes { number state url updatedAt author { login } }
+          }
+          timelineItems(itemTypes: [CROSS_REFERENCED_EVENT], last: 30) {
+            nodes {
+              ... on CrossReferencedEvent {
+                source {
+                  ... on PullRequest { number state url updatedAt author { login } }
+                }
+              }
+            }
+          }
+        }
+      }
+    }`, { owner, repo, number: issueNumber });
+  const issue2 = data.repository?.issue;
+  if (!issue2) {
+    return {
+      passed: true,
+      inconclusive: true,
+      reason: "issue not returned by GraphQL",
+      linkedPR: null
+    };
+  }
+  const nodes = (issue2.closedByPullRequestsReferences?.nodes ?? []).filter((n) => n != null);
+  if (nodes.length > 0) {
+    const pr = [...nodes].sort((a, b) => CLOSING_PR_RANK[a.state] - CLOSING_PR_RANK[b.state])[0];
+    return { passed: false, linkedPR: toLinkedPR(pr) };
+  }
+  const openMentions = (issue2.timelineItems?.nodes ?? []).map((n) => n?.source).filter((s) => s?.state === "OPEN" && typeof s.number === "number" && typeof s.url === "string").map(toLinkedPR);
+  const own2 = openMentions.find((pr) => username !== "" && pr.author.toLowerCase() === username.toLowerCase());
+  if (own2)
+    return { passed: false, linkedPR: own2 };
+  const active = openMentions.filter((pr) => !isLinkedPRStalled(pr));
+  return {
+    passed: true,
+    linkedPR: null,
+    ...active.length > 0 ? { openMentions: active } : {}
+  };
+}
+async function checkNoExistingPR(octokit, owner, repo, issueNumber, opts = {}) {
   try {
+    if (opts.closingOnly) {
+      return await checkNoClosingPR(octokit, owner, repo, issueNumber, opts.username ?? "");
+    }
     const timeline = await paginateAll((page) => octokit.issues.listEventsForTimeline({
       owner,
       repo,
@@ -43747,9 +43863,15 @@ function analyzeRequirements(body) {
 
 // ../core/dist/core/probe-repo-file.js
 var MODULE6 = "probe-repo-file";
+var MISSING_FILE_TTL_MS = 4 * 60 * 60 * 1e3;
 async function probeRepoFile(octokit, owner, repo, path6) {
+  const url2 = `/repos/${owner}/${repo}/contents/${path6}`;
+  const missingKey = `missing:${url2}`;
+  if (getHttpCache().getIfFresh(missingKey, MISSING_FILE_TTL_MS) !== null) {
+    return { text: null, transient: false };
+  }
   try {
-    const data = await cachedRequest(getHttpCache(), `/repos/${owner}/${repo}/contents/${path6}`, (headers) => octokit.repos.getContent({ owner, repo, path: path6, headers }));
+    const data = await cachedRequest(getHttpCache(), url2, (headers) => octokit.repos.getContent({ owner, repo, path: path6, headers }));
     if (data && typeof data === "object" && "content" in data && typeof data.content === "string") {
       return {
         text: Buffer.from(data.content, "base64").toString("utf-8"),
@@ -43759,8 +43881,10 @@ async function probeRepoFile(octokit, owner, repo, path6) {
     return { text: null, transient: false };
   } catch (error62) {
     const status = getHttpStatusCode(error62);
-    if (status === 404)
+    if (status === 404) {
+      getHttpCache().set(missingKey, "", true);
       return { text: null, transient: false };
+    }
     rethrowIfFatal(error62);
     warn(MODULE6, `Unexpected error fetching ${path6} from ${owner}/${repo}: ${errorMessage(error62)}`);
     return { text: null, transient: true };
@@ -43770,23 +43894,18 @@ async function probeRepoFile(octokit, owner, repo, path6) {
 // ../core/dist/core/repo-health.js
 var MODULE7 = "repo-health";
 var MERGE_WINDOW_DAYS = 90;
-async function fetchRepoMergeStats(octokit, owner, repo, tracker) {
+async function fetchRepoMergeStats(octokit, owner, repo) {
   const since = new Date(Date.now() - MERGE_WINDOW_DAYS * 24 * 60 * 60 * 1e3).toISOString().slice(0, 10);
-  const count = async (qualifiers) => {
-    await tracker.waitForBudget();
-    try {
-      const { data } = await octokit.search.issuesAndPullRequests({
-        q: `repo:${owner}/${repo} ${qualifiers} closed:>=${since}`,
-        per_page: 1
-        // only total_count is needed
-      });
-      return data.total_count;
-    } finally {
-      tracker.recordCall();
-    }
-  };
-  const merged = await count("is:pr is:merged");
-  const closedUnmerged = await count("is:pr is:unmerged is:closed");
+  const scope = `repo:${owner}/${repo} is:pr closed:>=${since}`;
+  const data = await octokit.graphql(`query repoMergeStats($merged: String!, $closedUnmerged: String!) {
+      merged: search(type: ISSUE, query: $merged, first: 0) { issueCount }
+      closedUnmerged: search(type: ISSUE, query: $closedUnmerged, first: 0) { issueCount }
+    }`, {
+    merged: `${scope} is:merged`,
+    closedUnmerged: `${scope} is:unmerged is:closed`
+  });
+  const merged = data.merged.issueCount;
+  const closedUnmerged = data.closedUnmerged.issueCount;
   const denom = merged + closedUnmerged;
   return {
     recentMergedPRCount: merged,
@@ -43812,7 +43931,7 @@ function pruneCache() {
     }
   }
 }
-async function checkProjectHealth(octokit, owner, repo, tracker = getSearchBudgetTracker()) {
+async function checkProjectHealth(octokit, owner, repo) {
   const cache = getHttpCache();
   const healthCacheKey = versionedCacheKey(`health:${owner}/${repo}`);
   try {
@@ -43830,7 +43949,7 @@ async function checkProjectHealth(octokit, owner, repo, tracker = getSearchBudge
       const lastCommitAt = lastCommit?.commit?.author?.date || repoData.pushed_at;
       const daysSinceLastCommit = daysBetween(new Date(lastCommitAt));
       const ciStatus = "unknown";
-      const mergeStats = await fetchRepoMergeStats(octokit, owner, repo, tracker);
+      const mergeStats = await fetchRepoMergeStats(octokit, owner, repo);
       return {
         repo: `${owner}/${repo}`,
         lastCommitAt,
@@ -43900,11 +44019,14 @@ async function fetchContributionGuidelinesUncached(octokit, owner, repo) {
       return guidelines;
     }
   }
-  guidelinesCache.set(cacheKey, {
-    guidelines: void 0,
-    fetchedAt: Date.now()
-  });
-  pruneCache();
+  const transient = results.some((r) => r.status === "fulfilled" && r.value.transient);
+  if (!transient) {
+    guidelinesCache.set(cacheKey, {
+      guidelines: void 0,
+      fetchedAt: Date.now()
+    });
+    pruneCache();
+  }
   return void 0;
 }
 function parseContributionGuidelines(content) {
@@ -43976,7 +44098,15 @@ var ANTI_LLM_KEYWORDS = [
   "no use of generative ai",
   "ban on ai-generated",
   "prohibit ai-generated",
-  "prohibits ai-generated"
+  "prohibits ai-generated",
+  "not be completed by automated agents",
+  "must not be done by automated agents",
+  "tasks are for humans only",
+  // AGENTS.md bans (e.g. servo). Most AGENTS.md files are agent guides
+  // that welcome AI work, so only outright refusals are listed.
+  "do not generate code",
+  "explicitly rejected the generative use of agents",
+  "you are explicitly forbidden from modifying"
 ];
 function scanForAntiLLMPolicy(text) {
   if (!text)
@@ -44004,6 +44134,16 @@ var SOURCE_FILE_FAMILIES = [
       "code_of_conduct.md"
     ]
   },
+  {
+    // Agent instruction files; matched only on the refusal keywords above.
+    canonical: "AGENTS.md",
+    paths: ["AGENTS.md"]
+  },
+  {
+    // Repos that state an AI policy in a dedicated file (e.g. cot-rs/cot).
+    canonical: "AI_POLICY.md",
+    paths: ["AI_POLICY.md", ".github/AI_POLICY.md"]
+  },
   {
     canonical: "README.md",
     paths: ["README.md", "readme.md", "Readme.md"]
@@ -44082,6 +44222,11 @@ async function fetchAndScanAntiLLMPolicy(octokit, owner, repo, options) {
 
 // ../core/dist/core/issue-graphql.js
 var MODULE8 = "issue-graphql";
+function looksLikeBotLogin(login) {
+  if (!login)
+    return false;
+  return /(?:^|-)bot(?:-|$)/i.test(login);
+}
 function issueCoreKey(owner, repo, number4) {
   return `${owner}/${repo}#${number4}`;
 }
@@ -44094,7 +44239,11 @@ function normalizeNode(node2) {
     labels: node2.labels.nodes.map((l) => l.name),
     commentCount: node2.comments.totalCount,
     createdAt: node2.createdAt,
-    updatedAt: node2.updatedAt
+    updatedAt: node2.updatedAt,
+    authorLogin: node2.author?.login,
+    authorIsBot: node2.author?.__typename === "Bot" || /\[bot\]$/i.test(node2.author?.login ?? ""),
+    authorLooksLikeBot: looksLikeBotLogin(node2.author?.login),
+    authorIsMaintainer: MAINTAINER_ASSOCIATIONS.has(node2.authorAssociation ?? "")
   };
 }
 async function prefetchIssueCores(octokit, issues) {
@@ -44122,6 +44271,8 @@ async function prefetchIssueCores(octokit, issues) {
           comments { totalCount }
           createdAt
           updatedAt
+          author { login __typename }
+          authorAssociation
         }
       }`);
   });
@@ -44231,7 +44382,7 @@ async function graphqlSearchIssues(octokit, query, first) {
           title
           updatedAt
           labels(first: 20) { nodes { name } }
-          repository { nameWithOwner }
+          repository { nameWithOwner stargazerCount }
         }
       }
     }
@@ -44268,7 +44419,8 @@ async function graphqlSearchIssues(octokit, query, first) {
       repository_url: `https://api.github.com/repos/${nameWithOwner}`,
       updated_at: node2.updatedAt ?? "",
       title: node2.title,
-      labels: node2.labels?.nodes ?? []
+      labels: node2.labels?.nodes ?? [],
+      repositoryStars: node2.repository?.stargazerCount
     });
   }
   return { total_count: search.issueCount ?? 0, items };
@@ -44432,6 +44584,9 @@ function isValidTriageShape(value) {
 var MODULE10 = "issue-vetting";
 var MAX_CONCURRENT_VETTING = 3;
 var VETTING_CACHE_TTL_MS = 15 * 60 * 1e3;
+var DECIDED_LABEL = /\b(?:accepted|confirmed|approved|triaged|planned|help[- _]wanted)\b/i;
+var DECIDED_LABEL_VETO = /\b(?:not|needs?|to[- ]be|wontfix|duplicate|cla|answer)\b/i;
+var UNDECIDED_MARKER = /\b(?:tracking|epic|meta|rfc|roadmap|blocked|on[- ]hold|question|discussion|support|needs?[- ](?:info|design|discussion|triage|decision))\b/i;
 function repoAcceptsContributionsFromHealth(projectHealth) {
   if (projectHealth.checkFailed || projectHealth.recentMergedPRCount == null) {
     return null;
@@ -44507,6 +44662,8 @@ function deriveRecommendation(input2) {
   if (input2.issueClosed) {
     reasonsToSkip.push("Issue is closed");
   }
+  if (input2.notTakeableReason)
+    reasonsToSkip.push(input2.notTakeableReason);
   let recommendation;
   if (input2.issueClosed) {
     recommendation = "skip";
@@ -44514,6 +44671,8 @@ function deriveRecommendation(input2) {
     recommendation = "skip";
   } else if (input2.ownPR) {
     recommendation = "skip";
+  } else if (input2.notTakeableReason) {
+    recommendation = "skip";
   } else if (input2.passedAllChecks && input2.repoAcceptsContributions !== false) {
     recommendation = "approve";
   } else if (reasonsToSkip.length > 2) {
@@ -44526,6 +44685,11 @@ function deriveRecommendation(input2) {
     recommendation = "needs_review";
     notes.push("Recommendation downgraded: one or more checks were inconclusive");
   }
+  if (input2.cautionReasons?.length) {
+    reasonsToSkip.push(...input2.cautionReasons);
+    if (recommendation === "approve")
+      recommendation = "needs_review";
+  }
   return { notes, reasonsToApprove, reasonsToSkip, recommendation };
 }
 var IssueVetter = class {
@@ -44556,7 +44720,9 @@ 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 = versionedCacheKey(`vet:${issueUrl}${sigKey}`);
+    const complexMode = this.stateReader.getComplexIssuesMode?.() ?? "off";
+    const modeKey = complexMode === "off" ? "" : `:cx-${complexMode}`;
+    const cacheKey = versionedCacheKey(`vet:${issueUrl}${sigKey}${modeKey}`);
     const cached2 = cache.getIfFresh(cacheKey, VETTING_CACHE_TTL_MS);
     if (cached2 && typeof cached2 === "object" && "issue" in cached2 && "viabilityScore" in cached2) {
       debug(MODULE10, `Vetting cache hit for ${issueUrl}`);
@@ -44570,23 +44736,45 @@ var IssueVetter = class {
     const repoFullName = `${owner}/${repo}`;
     const core = opts?.prefetched ?? await this.fetchIssueCore(owner, repo, number4);
     const reposWithMergedPRs = this.stateReader.getReposWithMergedPRs();
-    const hasMergedPRsInRepo = reposWithMergedPRs.includes(repoFullName);
+    const repoLower = repoFullName.toLowerCase();
+    const hasMergedPRsInRepo = reposWithMergedPRs.some((r) => r.toLowerCase() === repoLower);
+    const complexityUnlocked = complexMode === "warm" && hasMergedPRsInRepo;
+    const username = this.stateReader.getGitHubUsername?.() ?? "";
     const [existingPRCheck, claimCheck, projectHealth, contributionGuidelines, userMergedPRCount] = await Promise.all([
-      checkNoExistingPR(this.octokit, owner, repo, number4),
+      checkNoExistingPR(this.octokit, owner, repo, number4, {
+        closingOnly: complexityUnlocked,
+        username
+      }),
       checkNotClaimed(this.octokit, owner, repo, number4, core.commentCount),
-      checkProjectHealth(this.octokit, owner, repo, this.budgetTracker),
+      checkProjectHealth(this.octokit, owner, repo),
       fetchContributionGuidelines(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 username = this.stateReader.getGitHubUsername?.() ?? "";
+    const isOwnIssue = username !== "" && core.authorLogin?.toLowerCase() === username.toLowerCase();
+    let notTakeableReason;
+    if (core.authorIsBot) {
+      notTakeableReason = "Filed by a bot account";
+    } else if (!isOwnIssue && commentClaimsIssue(core.body)) {
+      notTakeableReason = "Reporter offered to send the fix";
+    }
+    const cautionReasons = [];
+    if (!core.authorIsBot && core.authorLooksLikeBot)
+      cautionReasons.push("Author login looks like a bot");
+    const openMentions = existingPRCheck.openMentions ?? [];
+    if (openMentions.length > 0)
+      cautionReasons.push(`Open PR ${openMentions.map((pr) => `#${pr.number}`).join(", ")} mentions this issue`);
+    if (antiLLMPolicy.matched)
+      cautionReasons.push(`AI contribution policy in ${antiLLMPolicy.sourceFile ?? "repo docs"}`);
     const linkedPR = existingPRCheck.linkedPR;
     const ownPR = !noExistingPR && !!linkedPR && linkedPR.state === "open" && !linkedPR.merged && username !== "" && linkedPR.author.toLowerCase() === username.toLowerCase();
     const linkedPRMerged = !!linkedPR && linkedPR.merged;
     const linkedPRClosed = !!linkedPR && linkedPR.state === "closed" && !linkedPR.merged;
-    const clearRequirements = analyzeRequirements(core.body);
+    const bodyIsClear = analyzeRequirements(core.body);
+    const maintainerDecided = complexityUnlocked && !bodyIsClear && core.body.trim().length >= 50 && ![core.title, ...core.labels].some((t) => UNDECIDED_MARKER.test(t)) && (!!core.authorIsMaintainer && !isOwnIssue || core.labels.some((l) => DECIDED_LABEL.test(l) && !DECIDED_LABEL_VETO.test(l)));
+    const clearRequirements = bodyIsClear || maintainerDecided;
     const projectActive = projectHealth.checkFailed ? true : projectHealth.isActive;
     const repoAcceptsContributions = repoAcceptsContributionsFromHealth(projectHealth);
     const vettingResult = {
@@ -44647,9 +44835,13 @@ var IssueVetter = class {
       matchesCategory,
       issueClosed,
       passedAllChecks: vettingResult.passedAllChecks,
-      repoAcceptsContributions
+      repoAcceptsContributions,
+      notTakeableReason,
+      cautionReasons
     });
     vettingResult.notes = notes;
+    if (maintainerDecided)
+      notes.push("Requirements taken as decided: maintainer-filed or triage-accepted");
     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");
@@ -44698,7 +44890,8 @@ var IssueVetter = class {
       reasonsToSkip,
       reasonsToApprove,
       viabilityScore,
-      searchPriority
+      searchPriority,
+      ...complexityUnlocked ? { complexityUnlocked: true } : {}
     };
     if (!hasInconclusiveChecks) {
       cache.set(cacheKey, "", result);
@@ -44724,7 +44917,11 @@ var IssueVetter = class {
       labels: ghIssue.labels.map((l) => typeof l === "string" ? l : l.name || ""),
       commentCount: ghIssue.comments,
       createdAt: ghIssue.created_at,
-      updatedAt: ghIssue.updated_at
+      updatedAt: ghIssue.updated_at,
+      authorLogin: ghIssue.user?.login,
+      authorIsBot: ghIssue.user?.type === "Bot" || /\[bot\]$/i.test(ghIssue.user?.login ?? ""),
+      authorLooksLikeBot: looksLikeBotLogin(ghIssue.user?.login),
+      authorIsMaintainer: MAINTAINER_ASSOCIATIONS.has(ghIssue.author_association ?? "")
     };
   }
   /**
@@ -44913,7 +45110,7 @@ async function cachedSearchIssues(octokit, params, tracker = getSearchBudgetTrac
   return data;
 }
 async function searchIssuesGraphQLFirst(octokit, params, tracker = getSearchBudgetTracker()) {
-  const cacheKey = versionedCacheKey(`gqlsearch:${params.q}:${params.sort}:${params.order}:${params.per_page}`);
+  const cacheKey = versionedCacheKey(`gqlsearch2:${params.q}:${params.sort}:${params.order}:${params.per_page}`);
   const cache = getHttpCache();
   const cached2 = cache.getIfFresh(cacheKey, SEARCH_CACHE_TTL_MS);
   if (cached2) {
@@ -45096,14 +45293,22 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
     const spamCount = items.filter((i) => spamRepos.has(extractRepoFromUrl(i.repository_url) ?? "")).length;
     debug(MODULE11, `[SPAM_FILTER] Filtered ${spamCount} issues from ${spamRepos.size} label-farming repos: ${[...spamRepos].join(", ")}`);
   }
+  let preVetStarDropped = 0;
   const itemsToVet = filterIssues(items).filter((item) => {
     const repoFullName = extractRepoFromUrl(item.repository_url);
     if (!repoFullName)
       return false;
     if (spamRepos.has(repoFullName))
       return false;
+    if (typeof item.repositoryStars === "number" && item.repositoryStars < minStars) {
+      preVetStarDropped++;
+      return false;
+    }
     return excludedRepoSets.every((s) => !s.has(repoFullName));
   }).slice(0, remainingNeeded * 2);
+  if (preVetStarDropped > 0) {
+    debug(MODULE11, `[STAR_FILTER] Dropped ${preVetStarDropped} ${phaseLabel} items below ${minStars} stars before vetting`);
+  }
   if (itemsToVet.length === 0) {
     debug(MODULE11, `[${phaseLabel}] All ${items.length} items filtered before vetting`);
     return { candidates: [], allVetFailed: false, rateLimitHit: false };
@@ -45122,6 +45327,216 @@ async function filterVetAndScore(vetter, items, filterIssues, excludedRepoSets,
   return { candidates: starFiltered, allVetFailed, rateLimitHit };
 }
 
+// ../core/dist/core/warm-repos.js
+var MODULE12 = "warm-repos";
+var BATCH_SIZE = 8;
+var ISSUES_PER_REPO = 30;
+var INTER_BATCH_DELAY_MS = 500;
+var MAX_DEAD_BATCHES = 2;
+var GH_NAME_PATTERN2 = /^[A-Za-z0-9_.-]+$/;
+var VET_PER_REPO = KNOWN_REPO_PER_REPO_CAP + 1;
+var MAX_VETS = 60;
+var SKIP_MEMORY_MS = 24 * 60 * 60 * 1e3;
+var PERMANENT_ERROR_TYPES = /* @__PURE__ */ new Set(["NOT_FOUND", "FORBIDDEN"]);
+async function queryRepos(octokit, repos, noRetry = false) {
+  const varDefs = [];
+  const selections = [];
+  const variables = {};
+  repos.forEach((fullName, i) => {
+    const [owner, name] = fullName.split("/");
+    varDefs.push(`$o${i}: String!, $n${i}: String!`);
+    variables[`o${i}`] = owner;
+    variables[`n${i}`] = name;
+    selections.push(`r${i}: repository(owner: $o${i}, name: $n${i}) {
+        nameWithOwner
+        isArchived
+        stargazerCount
+        issues(first: ${ISSUES_PER_REPO}, states: OPEN, orderBy: { field: CREATED_AT, direction: DESC }) {
+          nodes {
+            url
+            title
+            createdAt
+            updatedAt
+            authorAssociation
+            viewerDidAuthor
+            assignees { totalCount }
+            comments { totalCount }
+            labels(first: 10) { nodes { name } }
+            closedByPullRequestsReferences(first: 1, includeClosedPrs: false) { totalCount }
+          }
+        }
+      }`);
+  });
+  const query = `query warmRepoIssues(${varDefs.join(", ")}) {
+${selections.join("\n")}
+}`;
+  try {
+    return {
+      data: await octokit.graphql(query, {
+        ...variables,
+        ...noRetry ? { request: { retries: 0 } } : {}
+      }),
+      permanent: /* @__PURE__ */ new Set()
+    };
+  } catch (err) {
+    const partial2 = err.data;
+    if (!partial2 || isRateLimitError(err))
+      throw err;
+    const gqlErrors = err.errors ?? [];
+    return {
+      data: partial2,
+      permanent: new Set(gqlErrors.filter((e) => PERMANENT_ERROR_TYPES.has(e.type ?? "")).map((e) => String(e.path?.[0])))
+    };
+  }
+}
+function takeableIssues(listedAs, node2, minStars) {
+  const nodes = node2?.issues?.nodes;
+  if (!node2 || !nodes)
+    return null;
+  if (node2.isArchived)
+    return [];
+  if ((node2.stargazerCount ?? 0) < minStars)
+    return [];
+  const repo = node2.nameWithOwner;
+  return nodes.flatMap((n) => {
+    if (!n)
+      return [];
+    if (n.assignees.totalCount > 0)
+      return [];
+    if ((n.closedByPullRequestsReferences?.totalCount ?? 0) > 0)
+      return [];
+    return [
+      {
+        html_url: n.url,
+        repository_url: `https://api.github.com/repos/${repo}`,
+        updated_at: n.updatedAt,
+        title: n.title,
+        labels: (n.labels?.nodes ?? []).map((l) => ({ name: l.name })),
+        repo,
+        listedAs,
+        createdAt: n.createdAt,
+        maintainerFiled: MAINTAINER_ASSOCIATIONS.has(n.authorAssociation) && !n.viewerDidAuthor,
+        commentCount: n.comments.totalCount
+      }
+    ];
+  });
+}
+async function listWarmRepoIssues(octokit, repos, minStars = 0) {
+  const valid = repos.filter((r) => {
+    const parts = r.split("/");
+    return parts.length === 2 && parts.every((p) => GH_NAME_PATTERN2.test(p));
+  });
+  const byUrl = /* @__PURE__ */ new Map();
+  let failedRepos = repos.length - valid.length;
+  let rateLimitHit = false;
+  const read = async (batch, noRetry = false) => {
+    try {
+      const { data, permanent } = await queryRepos(octokit, batch, noRetry);
+      const retry2 = [];
+      batch.forEach((repo, j) => {
+        const found = takeableIssues(repo, data[`r${j}`], minStars);
+        if (found)
+          for (const issue2 of found)
+            byUrl.set(issue2.html_url, issue2);
+        else if (batch.length > 1 && !permanent.has(`r${j}`))
+          retry2.push(repo);
+        else
+          failedRepos++;
+      });
+      return retry2;
+    } catch (err) {
+      if (getHttpStatusCode(err) === 401)
+        throw err;
+      if (isRateLimitError(err)) {
+        warn(MODULE12, `Rate limit hit listing warm repos: ${errorMessage(err)}`);
+        rateLimitHit = true;
+        return [];
+      }
+      warn(MODULE12, `Failed to list issues for ${batch.join(", ")}: ${errorMessage(err)}`);
+      return null;
+    }
+  };
+  let deadBatches = 0;
+  for (let i = 0; i < valid.length && !rateLimitHit; i += BATCH_SIZE) {
+    if (i > 0)
+      await sleep(INTER_BATCH_DELAY_MS);
+    const batch = valid.slice(i, i + BATCH_SIZE);
+    const first = await read(batch);
+    let alive = first !== null;
+    if (first === null && batch.length === 1)
+      failedRepos++;
+    for (const repo of first ?? (batch.length > 1 ? batch : [])) {
+      if (rateLimitHit)
+        break;
+      if (await read([repo], first === null) === null)
+        failedRepos++;
+      else
+        alive = true;
+    }
+    deadBatches = alive ? 0 : deadBatches + 1;
+    if (deadBatches >= MAX_DEAD_BATCHES) {
+      warn(MODULE12, `${deadBatches} batches in a row returned nothing; stopping the warm-repo walk`);
+      failedRepos += Math.max(0, valid.length - (i + batch.length));
+      break;
+    }
+  }
+  return { items: [...byUrl.values()], failedRepos, rateLimitHit };
+}
+var DAY_MS = 24 * 60 * 60 * 1e3;
+function rankWarmIssues(items, repoScore, now = /* @__PURE__ */ new Date()) {
+  const score = (issue2) => {
+    const ageDays = (now.getTime() - Date.parse(issue2.createdAt)) / DAY_MS;
+    const freshness = ageDays <= 2 ? 3 : ageDays <= 14 ? 2 : ageDays <= 30 ? 1 : 0;
+    return freshness + (issue2.maintainerFiled ? 3 : 0) + (issue2.commentCount === 0 ? 2 : 0) + (repoScore(issue2.repo) ?? repoScore(issue2.listedAs) ?? 5) / 2;
+  };
+  return items.map((issue2) => ({ issue: issue2, score: score(issue2) })).sort((a, b) => b.score - a.score || Date.parse(b.issue.createdAt) - Date.parse(a.issue.createdAt)).map((entry) => entry.issue);
+}
+var skipMemoryKey = (url2) => versionedCacheKey(`warm-skip:${url2}`);
+async function fetchWarmRepoCandidates(octokit, vetter, repos, maxResults, filterFn, repoScore, minStars = 0) {
+  const cache = getHttpCache();
+  const listed = await listWarmRepoIssues(octokit, repos, minStars);
+  const passing = (items) => new Set(filterFn(items).map((i) => i.html_url));
+  const kept = passing(listed.items);
+  const keptAsListed = passing(listed.items.map((i) => ({
+    ...i,
+    repository_url: `https://api.github.com/repos/${i.listedAs}`
+  })));
+  const ranked = rankWarmIssues(listed.items.filter((i) => kept.has(i.html_url) && keptAsListed.has(i.html_url) && cache.getEntryIfFresh(skipMemoryKey(i.html_url), SKIP_MEMORY_MS) === null), repoScore);
+  const toVet = applyPerRepoCap(ranked.map((i) => ({ url: i.html_url, issue: { repo: i.repo } })), VET_PER_REPO).slice(0, Math.min(maxResults * 2, MAX_VETS)).map((i) => i.url);
+  let candidates = [];
+  let rateLimitHit = listed.rateLimitHit;
+  let vetError = null;
+  if (toVet.length > 0 && !listed.rateLimitHit) {
+    try {
+      const vetted = await vetter.vetIssuesParallel(toVet, toVet.length, "merged_pr");
+      rateLimitHit ||= vetted.rateLimitHit;
+      for (const c of vetted.candidates) {
+        if (c.recommendation === "skip") {
+          cache.set(skipMemoryKey(c.issue.url), "", true);
+        }
+      }
+      const rank = new Map(toVet.map((url2, i) => [url2, i]));
+      const byRank = [...vetted.candidates].sort((a, b) => (rank.get(a.issue.url) ?? 0) - (rank.get(b.issue.url) ?? 0));
+      candidates = applyPerRepoCap([
+        ...byRank.filter((c) => c.recommendation !== "skip"),
+        ...byRank.filter((c) => c.recommendation === "skip")
+      ], KNOWN_REPO_PER_REPO_CAP).slice(0, maxResults);
+    } catch (err) {
+      if (getHttpStatusCode(err) === 401)
+        throw err;
+      rateLimitHit ||= isRateLimitError(err);
+      vetError = errorMessage(err);
+      warn(MODULE12, `Vetting warm-repo issues failed: ${vetError}`);
+    }
+  }
+  return {
+    candidates,
+    allReposFailed: repos.length > 0 && listed.failedRepos >= repos.length,
+    rateLimitHit,
+    vetError
+  };
+}
+
 // ../core/dist/core/personalization.js
 var REPO_BOOST = 20;
 var LANGUAGE_BOOST = 10;
@@ -45210,13 +45625,12 @@ function applyDiversityRatio(candidates, maxResults, diversityRatio) {
 }
 
 // ../core/dist/core/issue-discovery.js
-var MODULE12 = "issue-discovery";
+var MODULE13 = "issue-discovery";
 var LOW_BUDGET_THRESHOLD = 20;
 var CRITICAL_BUDGET_THRESHOLD = 10;
-var PHASE0_PER_PAGE = 30;
 var CONTRIBUTED_REPO_MAX_AGE_DAYS = 365;
-var PHASE0_MAX_SHARE = 0.5;
-var PHASE0_REPOS_PER_RUN = 10;
+var PHASE0_MAX_SHARE = 0.8;
+var PHASE0_MAX_REPOS = 200;
 var STARRED_REPOS_PER_RUN = 10;
 var MAINTAINED_REPOS_PER_RUN = 15;
 function rotatingWindow(items, size, offset) {
@@ -45253,34 +45667,35 @@ function buildIssueFilter(config2) {
         return false;
       if (!config2.includeDocIssues && isDocOnlyIssue(item))
         return false;
-      if (isNonActionableIssue(item))
+      const labelsOnly = item.maintainerFiled === true && config2.complexRepos.has(repoLower);
+      if (isNonActionableIssue(item, { labelsOnly }))
         return false;
       return true;
     });
   };
 }
-async function runPhase0(octokit, vetter, repos, maxResults, filterIssues) {
-  info(MODULE12, `Phase 0: Searching issues in ${repos.length} merged-PR repos (no label filter, ${PHASE0_PER_PAGE}/repo)...`);
-  const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, repos, [], maxResults, "merged_pr", filterIssues, PHASE0_PER_PAGE);
-  info(MODULE12, `Found ${candidates.length} candidates from merged-PR repos`);
+async function runPhase0(octokit, vetter, repos, maxResults, filterIssues, repoScore, minStars) {
+  info(MODULE13, `Phase 0: Listing open issues in ${repos.length} merged-PR repos (no label filter)...`);
+  const { candidates, allReposFailed, rateLimitHit, vetError } = await fetchWarmRepoCandidates(octokit, vetter, repos, maxResults, filterIssues, repoScore, minStars);
+  info(MODULE13, `Found ${candidates.length} candidates from merged-PR repos`);
   return {
     candidates,
-    error: allReposFailed ? "All merged-PR repo fetches failed" : null,
+    error: allReposFailed ? "All merged-PR repo fetches failed" : vetError,
     rateLimitHit
   };
 }
 var MAX_QUERY_ORGS = 8;
 async function runPhaseOrgs(octokit, vetter, orgs, languages, isAnyLanguage, labels, maxResults, minStars, phase0RepoSet, starredRepoSet, filterIssues, tracker) {
-  info(MODULE12, `Orgs phase: searching ${orgs.length} preferred org(s)...`);
+  info(MODULE13, `Orgs phase: searching ${orgs.length} preferred org(s)...`);
   const queryOrgs = orgs.slice(0, MAX_QUERY_ORGS);
   if (orgs.length > MAX_QUERY_ORGS) {
-    warn(MODULE12, `Orgs phase: capping query at ${MAX_QUERY_ORGS} org(s); dropping ${orgs.slice(MAX_QUERY_ORGS).join(", ")}`);
+    warn(MODULE13, `Orgs phase: capping query at ${MAX_QUERY_ORGS} org(s); dropping ${orgs.slice(MAX_QUERY_ORGS).join(", ")}`);
   }
   const orgQuery = queryOrgs.map((o) => `org:${o}`).join(" ");
   try {
     const allItems = await searchAcrossLanguagesAndLabels(octokit, languages, isAnyLanguage, labels, (langQ) => `is:issue is:open ${langQ} no:assignee ${orgQuery}`.replace(/  +/g, " ").trim(), maxResults * 3, tracker, 0, queryOrgs.length);
     const { candidates, allVetFailed, rateLimitHit } = await filterVetAndScore(vetter, allItems, filterIssues, [phase0RepoSet, starredRepoSet], maxResults, minStars, "Orgs phase");
-    info(MODULE12, `Found ${candidates.length} candidates from preferred orgs`);
+    info(MODULE13, `Found ${candidates.length} candidates from preferred orgs`);
     return {
       candidates,
       error: allVetFailed ? "all vetting failed" : null,
@@ -45290,7 +45705,7 @@ async function runPhaseOrgs(octokit, vetter, orgs, languages, isAnyLanguage, lab
     if (getHttpStatusCode(error62) === 401)
       throw error62;
     const errMsg = errorMessage(error62);
-    warn(MODULE12, `Error in preferred-orgs search: ${errMsg}`);
+    warn(MODULE13, `Error in preferred-orgs search: ${errMsg}`);
     return {
       candidates: [],
       error: errMsg,
@@ -45299,11 +45714,11 @@ async function runPhaseOrgs(octokit, vetter, orgs, languages, isAnyLanguage, lab
   }
 }
 async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssues) {
-  info(MODULE12, `Phase 1: Searching issues in ${repos.length} starred repos...`);
+  info(MODULE13, `Phase 1: Searching issues in ${repos.length} starred repos...`);
   const phase1Labels = labels.slice(0, 3);
   const reposToSearch = repos.slice(0, STARRED_REPOS_PER_RUN);
   const { candidates, allReposFailed, rateLimitHit } = await fetchIssuesFromKnownRepos(octokit, vetter, reposToSearch, phase1Labels, maxResults, "starred", filterIssues);
-  info(MODULE12, `Found ${candidates.length} candidates from starred repos`);
+  info(MODULE13, `Found ${candidates.length} candidates from starred repos`);
   return {
     candidates,
     error: allReposFailed ? "All starred repo fetches failed" : null,
@@ -45311,14 +45726,14 @@ async function runPhase1(octokit, vetter, repos, labels, maxResults, filterIssue
   };
 }
 async function runPhase2(octokit, vetter, scopes, labels, configLabels, languages, isAnyLanguage, maxResults, minStars, phase0RepoSet, starredRepoSet, existingCandidates, filterIssues, tracker, languageRotationOffset = 0) {
-  info(MODULE12, "Phase 2: General issue search...");
+  info(MODULE13, "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(MODULE12, `Scope "${scope}" has no labels, skipping tier`);
+        warn(MODULE13, `Scope "${scope}" has no labels, skipping tier`);
         continue;
       }
       tierLabelGroups.push({ tier: scope, tierLabels: scopeLabels });
@@ -45338,7 +45753,7 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
   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, tracker, languageRotationOffset);
-      info(MODULE12, `Phase 2 [${tier}]: processing ${allItems.length} items...`);
+      info(MODULE13, `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)
@@ -45349,7 +45764,7 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
       if (vetRateLimitHit) {
         rateLimitHit = true;
       }
-      info(MODULE12, `Found ${tierCandidates.length} candidates from ${tier} tier`);
+      info(MODULE13, `Found ${tierCandidates.length} candidates from ${tier} tier`);
     } catch (err) {
       if (getHttpStatusCode(err) === 401)
         throw err;
@@ -45358,13 +45773,13 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
       if (isRateLimitError(err)) {
         rateLimitHit = true;
       }
-      warn(MODULE12, `Error in ${tier} tier search: ${errMsg}`);
+      warn(MODULE13, `Error in ${tier} tier search: ${errMsg}`);
       tierResults.push([]);
     }
   }
   const interleaved = interleaveArrays(tierResults);
   if (interleaved.length === 0 && error62) {
-    warn(MODULE12, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error62}`);
+    warn(MODULE13, `All ${tierLabelGroups.length} scope tiers failed in Phase 2: ${error62}`);
   }
   return {
     candidates: interleaved.slice(0, maxResults),
@@ -45373,17 +45788,17 @@ async function runPhase2(octokit, vetter, scopes, labels, configLabels, language
   };
 }
 async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories, maxResults, phase0RepoSet, starredRepoSet, starredRepos, existingCandidates, filterIssues, tracker, rotationOffset = 0) {
-  info(MODULE12, "Phase 3: Searching actively maintained repos...");
+  info(MODULE13, "Phase 3: Searching actively maintained repos...");
   const seenRepos = new Set(existingCandidates.map((c) => c.issue.repo));
   const eligibleStarred = rotatingWindow(starredRepos, MAINTAINED_REPOS_PER_RUN, rotationOffset).filter((r) => !phase0RepoSet.has(r) && !seenRepos.has(r));
   if (eligibleStarred.length > 0) {
-    info(MODULE12, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
+    info(MODULE13, `Phase 3: Checking ${eligibleStarred.length} starred repos via REST API...`);
     const restItems = await fetchIssuesFromMaintainedRepos(octokit, eligibleStarred, 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(MODULE12, `Found ${candidates.length} candidates from maintained-repo REST search`);
+          info(MODULE13, `Found ${candidates.length} candidates from maintained-repo REST search`);
           return {
             candidates,
             error: allVetFailed ? "all vetting failed" : null,
@@ -45393,11 +45808,11 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       } catch (error62) {
         if (getHttpStatusCode(error62) === 401)
           throw error62;
-        warn(MODULE12, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error62));
+        warn(MODULE13, `Phase 3 REST vetting failed, falling back to Search API:`, errorMessage(error62));
       }
     }
   }
-  info(MODULE12, "Phase 3: Falling back to Search API...");
+  info(MODULE13, "Phase 3: Falling back to Search API...");
   const thirtyDaysAgo = /* @__PURE__ */ new Date();
   thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
   const pushedSince = thirtyDaysAgo.toISOString().split("T")[0];
@@ -45411,9 +45826,9 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
       order: "desc",
       per_page: maxResults * 3
     }, tracker);
-    info(MODULE12, `Found ${data.total_count} issues in maintained-repo search, processing top ${data.items.length}...`);
+    info(MODULE13, `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(MODULE12, `Found ${candidates.length} candidates from maintained-repo search`);
+    info(MODULE13, `Found ${candidates.length} candidates from maintained-repo search`);
     return {
       candidates,
       error: allVetFailed ? "all vetting failed" : null,
@@ -45423,7 +45838,7 @@ async function runPhase3(octokit, vetter, langQuery, minStars, projectCategories
     if (getHttpStatusCode(error62) === 401)
       throw error62;
     const errMsg = errorMessage(error62);
-    warn(MODULE12, `Error in maintained-repo search: ${errMsg}`);
+    warn(MODULE13, `Error in maintained-repo search: ${errMsg}`);
     return {
       candidates: [],
       error: errMsg,
@@ -45507,7 +45922,7 @@ var IssueDiscovery = class {
     let rateLimitHitDuringSearch = false;
     const applyInterPhaseDelay = async () => {
       if (interPhaseDelay > 0) {
-        info(MODULE12, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
+        info(MODULE13, `Waiting ${(interPhaseDelay / 1e3).toFixed(0)}s between phases for rate limit management...`);
         await sleep(interPhaseDelay);
       }
     };
@@ -45530,23 +45945,23 @@ 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(MODULE12, this.rateLimitWarning);
+        warn(MODULE13, this.rateLimitWarning);
       }
       if (searchBudget < CRITICAL_BUDGET_THRESHOLD) {
-        info(MODULE12, `Search budget critical (${searchBudget} remaining) \u2014 skipping the starred phase; broad/maintained still run on GraphQL (points bucket)`);
+        info(MODULE13, `Search budget critical (${searchBudget} remaining) \u2014 skipping the starred phase; broad/maintained still run on GraphQL (points bucket)`);
       } else if (searchBudget < LOW_BUDGET_THRESHOLD) {
-        info(MODULE12, `Search budget low (${searchBudget} remaining) \u2014 broad/maintained run on GraphQL (points bucket), unaffected by REST search quota`);
+        info(MODULE13, `Search budget low (${searchBudget} remaining) \u2014 broad/maintained run on GraphQL (points bucket), unaffected by REST search quota`);
       }
     } catch (error62) {
       if (getHttpStatusCode(error62) === 401)
         throw error62;
       preflightFailed = true;
       tracker.init(CRITICAL_BUDGET_THRESHOLD, new Date(Date.now() + 6e4).toISOString());
-      warn(MODULE12, "Could not check rate limit \u2014 using conservative budget, skipping the starred phase:", errorMessage(error62));
+      warn(MODULE13, "Could not check rate limit \u2014 using conservative budget, skipping the starred phase:", errorMessage(error62));
     }
     if (searchBudget <= 0) {
       this.rateLimitWarning = "GitHub search API quota exhausted \u2014 skipping the starred phase; other phases don't use it.";
-      warn(MODULE12, this.rateLimitWarning);
+      warn(MODULE13, this.rateLimitWarning);
     }
     const mergedPRRepos = this.stateReader.getReposWithMergedPRs();
     const openPRRepos = this.stateReader.getReposWithOpenPRs();
@@ -45557,7 +45972,7 @@ var IssueDiscovery = class {
     const langQuery = isAnyLanguage ? "" : languages.map((l) => `language:${l}`).join(" ");
     const aiBlocklisted = new Set(config2.aiPolicyBlocklist.map((r) => r.toLowerCase()));
     if (aiBlocklisted.size > 0) {
-      debug(MODULE12, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
+      debug(MODULE13, `[AI_POLICY_FILTER] Filtering issues from ${aiBlocklisted.size} blocklisted repo(s): ${[...aiBlocklisted].join(", ")}`);
     }
     const baseFilterConfig = {
       excludedRepos: new Set(config2.excludeRepos.map((r) => r.toLowerCase())),
@@ -45566,7 +45981,8 @@ var IssueDiscovery = class {
       lowScoringRepos,
       skippedUrls: options.skippedUrls ?? /* @__PURE__ */ new Set(),
       now: /* @__PURE__ */ new Date(),
-      includeDocIssues: config2.includeDocIssues ?? true
+      includeDocIssues: config2.includeDocIssues ?? true,
+      complexRepos: new Set(config2.complexIssues === "warm" ? mergedPRRepos.map((r) => r.toLowerCase()) : [])
     };
     const filterIssues = buildIssueFilter({
       ...baseFilterConfig,
@@ -45577,10 +45993,10 @@ var IssueDiscovery = class {
       maxAgeDays: CONTRIBUTED_REPO_MAX_AGE_DAYS
     });
     const repoRotation = options.repoRotationOffsets ?? {};
-    const phase0Repos = rotatingWindow([.../* @__PURE__ */ new Set([...mergedPRRepos, ...openPRRepos])], PHASE0_REPOS_PER_RUN, repoRotation.merged ?? 0);
+    const phase0Repos = enabledStrategies.has("merged") ? [.../* @__PURE__ */ new Set([...mergedPRRepos, ...openPRRepos])].slice(0, PHASE0_MAX_REPOS) : [];
     const phase0RepoSet = new Set(phase0Repos);
     const preferredOrgs = config2.preferredOrgs ?? [];
-    const starredToSearch = rotatingWindow(starredRepos, STARRED_REPOS_PER_RUN, repoRotation.starred ?? 0).filter((r) => !phase0RepoSet.has(r));
+    const starredToSearch = rotatingWindow(starredRepos.filter((r) => !phase0RepoSet.has(r)), STARRED_REPOS_PER_RUN, repoRotation.starred ?? 0);
     const canRun = {
       all: false,
       merged: phase0Repos.length > 0,
@@ -45592,7 +46008,7 @@ var IssueDiscovery = class {
     const broadDelay = options.broadPhaseDelayMs ?? config2.broadPhaseDelayMs ?? 0;
     const runStrategy = {
       merged: async (wanted) => {
-        recordPhaseResult("0", await runPhase0(this.octokit, this.vetter, phase0Repos, wanted, filterIssuesPhase0));
+        recordPhaseResult("0", await runPhase0(this.octokit, this.vetter, phase0Repos, wanted, filterIssuesPhase0, (repo) => this.stateReader.getRepoScore(repo), minStars));
         strategiesUsed.push("merged");
       },
       orgs: async (wanted) => {
@@ -45627,16 +46043,16 @@ var IssueDiscovery = class {
         }
         if (strategiesUsed.length > 0)
           await applyInterPhaseDelay();
-        info(MODULE12, `Round-robin: running the ${strategy} strategy`);
+        info(MODULE13, `Round-robin: running the ${strategy} strategy`);
         await runStrategy[strategy](maxResults - viableCandidateCount());
         if (viableCandidateCount() > 0)
           break;
       }
     } else {
       const orgsPhaseEnabled = canRun.orgs && enabledStrategies.has("orgs");
-      const otherStrategiesCanRun = orgsPhaseEnabled || starredRepos.length > 0 && enabledStrategies.has("starred") || enabledStrategies.has("broad") || enabledStrategies.has("maintained");
+      const otherStrategiesCanRun = orgsPhaseEnabled || canRun.starred && enabledStrategies.has("starred") || enabledStrategies.has("broad") || enabledStrategies.has("maintained");
       if (canRun.merged && enabledStrategies.has("merged")) {
-        const phase0Cap = otherStrategiesCanRun ? Math.max(1, Math.ceil(maxResults * PHASE0_MAX_SHARE)) : maxResults;
+        const phase0Cap = otherStrategiesCanRun ? Math.max(1, Math.min(Math.ceil(maxResults * PHASE0_MAX_SHARE), maxResults - 1)) : maxResults;
         await runStrategy.merged(Math.min(maxResults - allCandidates.length, phase0Cap));
       }
       if (allCandidates.length < maxResults && orgsPhaseEnabled) {
@@ -45653,26 +46069,26 @@ var IssueDiscovery = class {
       const skipThreshold = configuredSkipThreshold > 0 ? Math.min(configuredSkipThreshold, maxResults - 1) : 0;
       const viableBeforeBroad = viableCandidateCount();
       if (viableBeforeBroad >= maxResults && enabledStrategies.has("broad")) {
-        info(MODULE12, `Skipping broad search: ${viableBeforeBroad} viable candidate(s) already meet maxResults (${maxResults})`);
+        info(MODULE13, `Skipping broad search: ${viableBeforeBroad} viable candidate(s) already meet maxResults (${maxResults})`);
       } else if (enabledStrategies.has("broad")) {
         const preferredOrgSet = new Set(preferredOrgs.map((o) => o.toLowerCase()));
         const newRepoCandidateCount = allCandidates.filter((c) => c.recommendation !== "skip" && !phase0RepoSet.has(c.issue.repo) && !starredRepoSet.has(c.issue.repo) && !preferredOrgSet.has(c.issue.repo.split("/")[0]?.toLowerCase() ?? "")).length;
         if (skipThreshold > 0 && newRepoCandidateCount >= skipThreshold) {
-          info(MODULE12, `Skipping broad search: already found ${newRepoCandidateCount} viable candidate(s) from new repos (threshold: ${skipThreshold})`);
+          info(MODULE13, `Skipping broad search: already found ${newRepoCandidateCount} viable candidate(s) from new repos (threshold: ${skipThreshold})`);
         } else {
           await applyInterPhaseDelay();
           if (allCandidates.length > 0 && broadDelay > 0) {
-            info(MODULE12, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
+            info(MODULE13, `Waiting ${(broadDelay / 1e3).toFixed(0)}s for rate limit cooldown before broad search...`);
             await sleep(broadDelay);
           } else if (allCandidates.length === 0) {
-            info(MODULE12, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
+            info(MODULE13, `Skipping broad phase delay: no results from previous phases, proceeding immediately`);
           }
           await runStrategy.broad(maxResults - viableBeforeBroad);
         }
       }
       const viableBeforeMaintained = viableCandidateCount();
       if (viableBeforeMaintained >= maxResults && enabledStrategies.has("maintained")) {
-        info(MODULE12, `Skipping maintained search: ${viableBeforeMaintained} viable candidate(s) already meet maxResults (${maxResults})`);
+        info(MODULE13, `Skipping maintained search: ${viableBeforeMaintained} viable candidate(s) already meet maxResults (${maxResults})`);
       } else if (enabledStrategies.has("maintained")) {
         await applyInterPhaseDelay();
         await runStrategy.maintained(maxResults - viableBeforeMaintained);
@@ -45728,7 +46144,7 @@ var IssueDiscovery = class {
     ];
     const capped = applyPerRepoCap(viableFirst, 2);
     const finalPicks = applyDiversityRatio(capped, maxResults, options.diversityRatio ?? 0);
-    info(MODULE12, `Search complete: ${tracker.getTotalCalls()} REST Search API call(s) + ${getGraphQLSearchQueryCount()} GraphQL broad-search query/queries used, ${finalPicks.length} candidates returned`);
+    info(MODULE13, `Search complete: ${tracker.getTotalCalls()} REST Search API call(s) + ${getGraphQLSearchQueryCount()} GraphQL broad-search query/queries used, ${finalPicks.length} candidates returned`);
     return { candidates: finalPicks, strategiesUsed };
   }
   /**
@@ -45850,7 +46266,7 @@ async function fetchRoadmapIssueRefsUncached(octokit, owner, repo, cacheKey) {
 }
 
 // ../core/dist/core/feature-discovery.js
-var MODULE13 = "feature-discovery";
+var MODULE14 = "feature-discovery";
 var INTER_REPO_DELAY_MS = 2e3;
 var MIN_VIABILITY_SCORE = 40;
 var ANCHOR_THRESHOLD = 3;
@@ -45954,7 +46370,7 @@ function isFeatureIssue(item) {
     return false;
   return labels.some((l) => FEATURE_LABELS.includes(l));
 }
-async function vetAndClassify(item, vetter, roadmapRefs) {
+async function vetAndClassify(item, vetter, minStars, roadmapRefs) {
   const labels = extractLabels(item);
   const hasMilestone = !!item.milestone;
   const reactions = item.reactions?.total_count ?? 0;
@@ -45975,7 +46391,10 @@ async function vetAndClassify(item, vetter, roadmapRefs) {
     });
   } catch (err) {
     rethrowIfFatal(err);
-    warn(MODULE13, `vet failed for ${item.html_url}: ${errorMessage(err)}`);
+    warn(MODULE14, `vet failed for ${item.html_url}: ${errorMessage(err)}`);
+    return null;
+  }
+  if (!candidate.projectHealth.checkFailed && (candidate.projectHealth.stargazersCount ?? 0) < minStars) {
     return null;
   }
   const horizon = classifyHorizon({
@@ -46019,12 +46438,12 @@ async function discoverFeatures(opts) {
       roadmapRefs = refs;
     } catch (err) {
       rethrowIfFatal(err);
-      warn(MODULE13, `failed to list issues for ${anchorRepos[i]}: ${errorMessage(err)}`);
+      warn(MODULE14, `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 candidate = await vetAndClassify(item, opts.vetter, roadmapRefs);
+      const candidate = await vetAndClassify(item, opts.vetter, opts.minStars ?? 0, roadmapRefs);
       if (candidate)
         candidates.push(candidate);
     }
@@ -46101,7 +46520,7 @@ async function discoverFeaturesBroad(opts) {
     }).slice(0, maxToVet);
   } catch (err) {
     rethrowIfFatal(err);
-    warn(MODULE13, `broad feature search failed: ${errorMessage(err)}`);
+    warn(MODULE14, `broad feature search failed: ${errorMessage(err)}`);
     return {
       quickWins: [],
       biggerBets: [],
@@ -46111,7 +46530,7 @@ async function discoverFeaturesBroad(opts) {
   }
   const candidates = [];
   for (const item of items) {
-    const candidate = await vetAndClassify(item, opts.vetter);
+    const candidate = await vetAndClassify(item, opts.vetter, opts.minStars ?? 0);
     if (candidate)
       candidates.push(candidate);
   }
@@ -46126,9 +46545,58 @@ async function discoverFeaturesBroad(opts) {
 }
 
 // ../core/dist/core/gist-state-store.js
+var fs5 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// ../core/dist/core/local-state.js
 var fs4 = __toESM(require("fs"), 1);
 var path4 = __toESM(require("path"), 1);
-var MODULE14 = "gist-state";
+var MODULE15 = "local-state";
+function getStatePath() {
+  return path4.join(getDataDir(), "state.json");
+}
+function loadLocalState() {
+  const statePath = getStatePath();
+  try {
+    const raw = fs4.readFileSync(statePath, "utf-8");
+    return parseScoutState(JSON.parse(raw));
+  } catch (err) {
+    const code = err?.code;
+    if (code === "ENOENT") {
+      return ScoutStateSchema.parse({ version: 1 });
+    }
+    warn(MODULE15, `Failed to load state from ${statePath}: ${errorMessage(err)}. Using defaults.`);
+    try {
+      const backupPath = `${statePath}.corrupt.${Date.now()}`;
+      fs4.copyFileSync(statePath, backupPath);
+      warn(MODULE15, `Corrupt state backed up to ${backupPath}`);
+    } catch (backupErr) {
+      warn(MODULE15, `Failed to back up corrupt state: ${errorMessage(backupErr)}`);
+    }
+    return ScoutStateSchema.parse({ version: 1 });
+  }
+}
+var tmpCounter = 0;
+function saveLocalState(state) {
+  writeFileAtomic(getStatePath(), JSON.stringify(state, null, 2) + "\n");
+  debug(MODULE15, "State saved");
+}
+function writeFileAtomic(filePath, data) {
+  const tmpPath = `${filePath}.tmp.${process.pid}.${tmpCounter++}`;
+  fs4.writeFileSync(tmpPath, data, { mode: 384 });
+  try {
+    fs4.renameSync(tmpPath, filePath);
+  } catch (err) {
+    try {
+      fs4.unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+// ../core/dist/core/gist-state-store.js
+var MODULE16 = "gist-state";
 var GIST_DESCRIPTION = "oss-scout-state";
 var GIST_FILENAME = "state.json";
 var GIST_ID_FILE = "gist-id";
@@ -46152,10 +46620,10 @@ function classifyDegradedReason(err) {
   return "unknown";
 }
 function getGistIdPath() {
-  return path4.join(getDataDir(), GIST_ID_FILE);
+  return path5.join(getDataDir(), GIST_ID_FILE);
 }
 function getCachePath() {
-  return path4.join(getDataDir(), CACHE_FILE);
+  return path5.join(getDataDir(), CACHE_FILE);
 }
 var GistStateStore = class {
   octokit;
@@ -46173,7 +46641,7 @@ var GistStateStore = class {
     } catch (err) {
       if (getHttpStatusCode(err) === 401)
         throw err;
-      warn(MODULE14, `API bootstrap failed: ${errorMessage(err)}`);
+      warn(MODULE16, `API bootstrap failed: ${errorMessage(err)}`);
       return this.bootstrapFromCache(classifyDegradedReason(err));
     }
   }
@@ -46182,7 +46650,7 @@ var GistStateStore = class {
    */
   async push(state) {
     if (!this.gistId) {
-      warn(MODULE14, "No gist ID \u2014 cannot push");
+      warn(MODULE16, "No gist ID \u2014 cannot push");
       this.writeCache(state);
       return false;
     }
@@ -46193,17 +46661,17 @@ var GistStateStore = class {
         toWrite = mergeStates(state, remote.state);
       } else if (remote.kind === "invalid") {
         this.writeCache(state);
-        warn(MODULE14, "Remote gist content failed validation \u2014 not overwriting it. Changes saved locally; gist sync skipped.");
+        warn(MODULE16, "Remote gist content failed validation \u2014 not overwriting it. Changes saved locally; gist sync skipped.");
         return false;
       }
     } catch (err) {
       rethrowIfFatal(err);
-      warn(MODULE14, `Could not fetch gist before push, writing local snapshot: ${errorMessage(err)}`);
+      warn(MODULE16, `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(MODULE14, `State too large for gist (${Math.round(json2.length / 1024)}KB). Consider clearing old results with 'oss-scout results clear'.`);
+      warn(MODULE16, `State too large for gist (${Math.round(json2.length / 1024)}KB). Consider clearing old results with 'oss-scout results clear'.`);
       return false;
     }
     try {
@@ -46213,11 +46681,11 @@ var GistStateStore = class {
           [GIST_FILENAME]: { content: json2 }
         }
       });
-      debug(MODULE14, "State pushed to gist");
+      debug(MODULE16, "State pushed to gist");
       return true;
     } catch (err) {
       rethrowIfFatal(err);
-      warn(MODULE14, `Failed to push: ${errorMessage(err)}`);
+      warn(MODULE16, `Failed to push: ${errorMessage(err)}`);
       return false;
     }
   }
@@ -46229,7 +46697,7 @@ var GistStateStore = class {
   async bootstrapFromApi() {
     const cachedId = this.readCachedGistId();
     if (cachedId) {
-      debug(MODULE14, `Trying cached gist ID: ${cachedId}`);
+      debug(MODULE16, `Trying cached gist ID: ${cachedId}`);
       try {
         const fetched = await this.fetchGistState(cachedId);
         if (fetched.kind === "ok") {
@@ -46241,13 +46709,13 @@ var GistStateStore = class {
       } catch (err) {
         if (getHttpStatusCode(err) !== 404)
           throw err;
-        debug(MODULE14, `Cached gist gone (404): ${errorMessage(err)}`);
+        debug(MODULE16, `Cached gist gone (404): ${errorMessage(err)}`);
       }
-      debug(MODULE14, "Cached gist ID invalid, searching...");
+      debug(MODULE16, "Cached gist ID invalid, searching...");
     }
     const search = await this.searchForGist();
     if (search.id) {
-      debug(MODULE14, `Found gist via search: ${search.id}`);
+      debug(MODULE16, `Found gist via search: ${search.id}`);
       this.saveGistId(search.id);
       this.gistId = search.id;
       const fetched = await this.fetchGistState(search.id);
@@ -46256,13 +46724,13 @@ var GistStateStore = class {
         this.writeCache(state);
         return { gistId: search.id, state, created: false };
       }
-      warn(MODULE14, `Found existing gist ${search.id} but content failed validation. Using local cache to avoid data loss.`);
+      warn(MODULE16, `Found existing gist ${search.id} but content failed validation. Using local cache to avoid data loss.`);
       return this.bootstrapFromCache("unknown");
     }
     if (!search.exhaustive) {
-      warn(MODULE14, `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.`);
+      warn(MODULE16, `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(MODULE14, "No existing gist found, creating new one");
+    debug(MODULE16, "No existing gist found, creating new one");
     const freshState = ScoutStateSchema.parse({ version: 1 });
     const newId = await this.createGist(freshState);
     this.saveGistId(newId);
@@ -46273,7 +46741,7 @@ var GistStateStore = class {
   bootstrapFromCache(reason) {
     const cached2 = this.readCache();
     if (cached2) {
-      debug(MODULE14, "Bootstrapped from local cache (degraded mode)");
+      debug(MODULE16, "Bootstrapped from local cache (degraded mode)");
       const cachedId = this.readCachedGistId();
       if (cachedId)
         this.gistId = cachedId;
@@ -46285,7 +46753,7 @@ var GistStateStore = class {
         degradedReason: reason
       };
     }
-    debug(MODULE14, "No cache available, using fresh state (degraded mode)");
+    debug(MODULE16, "No cache available, using fresh state (degraded mode)");
     const fresh = ScoutStateSchema.parse({ version: 1 });
     return {
       gistId: "",
@@ -46312,7 +46780,7 @@ var GistStateStore = class {
       const parsed = JSON.parse(file2.content);
       return { kind: "ok", state: parseScoutState(parsed) };
     } catch (err) {
-      warn(MODULE14, `Gist content failed validation: ${errorMessage(err)}`);
+      warn(MODULE16, `Gist content failed validation: ${errorMessage(err)}`);
       return { kind: "invalid" };
     }
   }
@@ -46350,18 +46818,18 @@ var GistStateStore = class {
   // ── Local file helpers ───────────────────────────────────────────────
   readCachedGistId() {
     try {
-      const id = fs4.readFileSync(getGistIdPath(), "utf-8").trim();
+      const id = fs5.readFileSync(getGistIdPath(), "utf-8").trim();
       return id || null;
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") {
-        warn(MODULE14, `Failed to read cached gist ID: ${errorMessage(err)}`);
+        warn(MODULE16, `Failed to read cached gist ID: ${errorMessage(err)}`);
       }
       return null;
     }
   }
   saveGistId(id) {
-    fs4.writeFileSync(getGistIdPath(), id + "\n", { mode: 384 });
+    writeFileAtomic(getGistIdPath(), id + "\n");
   }
   /**
    * Merge the local state-cache into a freshly fetched gist state before it
@@ -46376,23 +46844,21 @@ var GistStateStore = class {
   }
   readCache() {
     try {
-      const raw = fs4.readFileSync(getCachePath(), "utf-8");
+      const raw = fs5.readFileSync(getCachePath(), "utf-8");
       return parseScoutState(JSON.parse(raw));
     } catch (err) {
       const code = err?.code;
       if (code !== "ENOENT") {
-        warn(MODULE14, `Failed to read state cache: ${errorMessage(err)}`);
+        warn(MODULE16, `Failed to read state cache: ${errorMessage(err)}`);
       }
       return null;
     }
   }
   writeCache(state) {
     try {
-      fs4.writeFileSync(getCachePath(), JSON.stringify(state, null, 2) + "\n", {
-        mode: 384
-      });
+      writeFileAtomic(getCachePath(), JSON.stringify(state, null, 2) + "\n");
     } catch (err) {
-      warn(MODULE14, `Failed to write cache: ${errorMessage(err)}`);
+      warn(MODULE16, `Failed to write cache: ${errorMessage(err)}`);
     }
   }
 };
@@ -46540,53 +47006,8 @@ function pickFresherTimestamp(a, b) {
   return a >= b ? a : b;
 }
 
-// ../core/dist/core/local-state.js
-var fs5 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
-var MODULE15 = "local-state";
-function getStatePath() {
-  return path5.join(getDataDir(), "state.json");
-}
-function loadLocalState() {
-  const statePath = getStatePath();
-  try {
-    const raw = fs5.readFileSync(statePath, "utf-8");
-    return parseScoutState(JSON.parse(raw));
-  } catch (err) {
-    const code = err?.code;
-    if (code === "ENOENT") {
-      return ScoutStateSchema.parse({ version: 1 });
-    }
-    warn(MODULE15, `Failed to load state from ${statePath}: ${errorMessage(err)}. Using defaults.`);
-    try {
-      const backupPath = `${statePath}.corrupt.${Date.now()}`;
-      fs5.copyFileSync(statePath, backupPath);
-      warn(MODULE15, `Corrupt state backed up to ${backupPath}`);
-    } catch (backupErr) {
-      warn(MODULE15, `Failed to back up corrupt state: ${errorMessage(backupErr)}`);
-    }
-    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";
-  fs5.writeFileSync(tmpPath, data, { mode: 384 });
-  try {
-    fs5.renameSync(tmpPath, statePath);
-  } catch (err) {
-    try {
-      fs5.unlinkSync(tmpPath);
-    } catch {
-    }
-    throw err;
-  }
-  debug(MODULE15, "State saved");
-}
-
 // ../core/dist/scout.js
+var LINKED_PR_SKIP_REASON = /Linked PR already merged|Linked PR closed without merge|Has existing PR/;
 function offlineModeMessage(reason) {
   const tail = "Changes will only be saved locally.";
   switch (reason) {
@@ -46696,7 +47117,8 @@ var OssScout = class {
   async search(options) {
     this.evictStaleCacheEntries();
     this.cullExpiredSkips();
-    const skippedUrls = new Set((this.state.skippedIssues ?? []).map((s) => s.url));
+    const unlockedRepos = new Set(this.getComplexIssuesMode() === "warm" ? this.getReposWithMergedPRs().map((r) => r.toLowerCase()) : []);
+    const skippedUrls = new Set((this.state.skippedIssues ?? []).filter((s) => !(unlockedRepos.has(s.repo.toLowerCase()) && LINKED_PR_SKIP_REASON.test(s.reason ?? ""))).map((s) => s.url));
     if (options?.excludeRecentlySurfaced ?? true) {
       const ttlDays = options?.recentlySurfacedTtlDays ?? 7;
       const cutoff = Date.now() - ttlDays * 24 * 60 * 60 * 1e3;
@@ -46843,6 +47265,7 @@ var OssScout = class {
       excludeRepos: this.state.preferences.excludeRepos,
       excludeOrgs: this.state.preferences.excludeOrgs,
       aiPolicyBlocklist: this.state.preferences.aiPolicyBlocklist,
+      minStars: this.state.preferences.minStars,
       splitRatio: options?.splitRatio ?? this.state.preferences.featuresSplitRatio
     }) : await discoverFeatures({
       octokit,
@@ -46852,6 +47275,7 @@ var OssScout = class {
       excludeRepos: this.state.preferences.excludeRepos,
       excludeOrgs: this.state.preferences.excludeOrgs,
       aiPolicyBlocklist: this.state.preferences.aiPolicyBlocklist,
+      minStars: this.state.preferences.minStars,
       anchorThreshold: options?.anchorThreshold ?? this.state.preferences.featuresAnchorThreshold,
       splitRatio: options?.splitRatio ?? this.state.preferences.featuresSplitRatio
     });
@@ -47025,6 +47449,9 @@ var OssScout = class {
       return null;
     return { model, host: this.state.preferences.slmTriageHost ?? "" };
   }
+  getComplexIssuesMode() {
+    return this.state.preferences.complexIssues ?? "off";
+  }
   /** Get current preferences (read-only). */
   getPreferences() {
     return this.state.preferences;
@@ -47456,6 +47883,7 @@ var FIELD_CONFIGS = {
   boostIssueTypes: { type: "array" },
   slmTriageModel: { type: "string" },
   slmTriageHost: { type: "string" },
+  complexIssues: { type: "enum", validValues: ComplexIssuesModeSchema.options },
   featuresAnchorThreshold: { type: "number" },
   featuresSplitRatio: { type: "float" }
 };
@@ -47948,7 +48376,7 @@ function registerResources(server, scout) {
 // src/index.ts
 var SERVER_INFO = {
   name: "oss-scout-mcp",
-  version: "0.13.1"
+  version: "0.13.2"
   // x-release-please-version
 };
 function createServer(scout) {