fix(miner): carry real assignees through the discovery-index supplement so the repo-owner exclusion applies (#7488)

discover-cli's supplementWithDiscoveryIndex stubbed assignees: [] on every hosted
discovery-index candidate, so contribution-profile-filter's always-on repo-owner
exclusion (#7040) -- which reads candidate.assignees -- could never fire for an
index-sourced candidate, silently no-opping the safeguard for that entire source.

Add an optional assignees field to DiscoveryIndexCandidate (normalized like labels,
kept optional so 'never served' is distinguishable from 'served empty') and copy the
real value through in supplementWithDiscoveryIndex, falling back to [] only when the
served response genuinely omitted it. isAssignedToRepoOwner's logic is unchanged; the
direct fan-out path already carried real assignees. Additive and backward-compatible.
Adds contract + end-to-end discover-cli regression tests.

Closes #7442

Author: xfodev

packages/loopover-engine/src/discovery-index-contract.ts

@@ -48,6 +48,11 @@ export type DiscoveryIndexCandidate = {
   issueNumber: number;
   title: string;
   labels: readonly string[];
+  /** Repo login(s) the issue is assigned to on GitHub (#7442). OPTIONAL: an older, backward-compatible hosted
+   *  server build that doesn't populate it leaves the field absent, which lets a client distinguish "assignees
+   *  were never served" from "served, and empty" -- the former falls back to [] at the merge site rather than
+   *  silently no-opping contribution-profile-filter's repo-owner exclusion (#7040). Normalized like `labels`. */
+  assignees?: readonly string[];
   commentsCount: number;
   createdAt: string | null;
   updatedAt: string | null;
@@ -197,13 +202,20 @@ export function normalizeDiscoveryIndexCandidate(raw: unknown): DiscoveryIndexCa
   const labels = Array.isArray(candidate.labels)
     ? candidate.labels.filter((label): label is string => typeof label === "string" && label.trim() !== "").map((label) => label.trim())
     : [];
+  // #7442: carry real assignees through when the server provides them (same string normalization as `labels`); an
+  // older build omits the field, leaving `assignees` off the result (undefined) so the merge site falls back to []
+  // -- fail-safe, never silently skipping the repo-owner exclusion filter.
+  const assignees = Array.isArray(candidate.assignees)
+    ? candidate.assignees.filter((entry): entry is string => typeof entry === "string" && entry.trim() !== "").map((entry) => entry.trim())
+    : undefined;
   return {
     owner,
     repo,
     repoFullName: canonical,
     issueNumber,
     title,
     labels,
+    ...(assignees !== undefined ? { assignees } : {}),
     commentsCount: typeof candidate.commentsCount === "number" && Number.isFinite(candidate.commentsCount) ? candidate.commentsCount : 0,
     createdAt: typeof candidate.createdAt === "string" ? candidate.createdAt : null,
     updatedAt: typeof candidate.updatedAt === "string" ? candidate.updatedAt : null,

packages/loopover-miner/lib/discover-cli.js

@@ -162,9 +162,11 @@ function dedupeKey(repoFullName: string, issueNumber: number): string {
  * no-op (returns `fanOut` unchanged) unless the plane is enabled, so a run with the flag unset behaves exactly
  * as before this feature existed. Local results always win on a duplicate issue (the discovery-index candidate
  * is dropped, not merged over it) -- this instance's own live fan-out is more current than a cached shared
- * index entry. Discovery-index candidates lack `assignees` (not part of the public contract), so they're
- * annotated with an empty array to match opportunity-fanout.js's own candidate shape; contribution-profile-
- * filter.js's assignee-exclusion rule treats that identically to "no assignees on this issue".
+ * index entry. Discovery-index candidates now carry their real `assignees` when the hosted contract supplies them
+ * (#7442): the value flows through so contribution-profile-filter.js's repo-owner exclusion (#7040) engages for
+ * index-sourced candidates exactly as it does for direct fan-out ones. A candidate whose response omitted the
+ * field (older discovery-index build) falls back to `[]` -- fail-safe: the filter still runs, it just can't detect
+ * an owner-assignment it was never told about, rather than the check being silently skipped.
  */
 async function supplementWithDiscoveryIndex(
   fanOut: DiscoverFanOutSummary,
@@ -181,9 +183,10 @@ async function supplementWithDiscoveryIndex(
   const seen = new Set(fanOut.issues.map((issue) => dedupeKey(issue.repoFullName, issue.issueNumber)));
   const supplemented = response.candidates
     .filter((candidate) => !seen.has(dedupeKey(candidate.repoFullName, candidate.issueNumber)))
-    // DiscoveryIndexCandidate is a near-superset of RawCandidateIssue; assignees is absent from the hosted
-    // contract (#7168) so we annotate [] — cast preserves pre-existing runtime shape rather than re-mapping.
-    .map((candidate) => ({ ...candidate, assignees: [], labels: [...candidate.labels] }) as RawCandidateIssue);
+    // DiscoveryIndexCandidate is a near-superset of RawCandidateIssue; copy the real assignees through when the
+    // hosted contract carried them (#7442), falling back to [] only when the served response genuinely omitted the
+    // field — cast preserves pre-existing runtime shape rather than re-mapping.
+    .map((candidate) => ({ ...candidate, assignees: [...(candidate.assignees ?? [])], labels: [...candidate.labels] }) as RawCandidateIssue);
   if (supplemented.length === 0) return fanOut;
   return { ...fanOut, issues: [...fanOut.issues, ...supplemented] };
 }

packages/loopover-miner/lib/discover-cli.ts

@@ -122,6 +122,18 @@ describe("discovery-index API contract (#4300)", () => {
       });
     });
 
+    it("normalizes assignees like labels, and omits the field entirely when the response never carries it (#7442)", () => {
+      // Present: filtered + trimmed exactly like labels (non-strings and blanks dropped).
+      expect(
+        normalizeDiscoveryIndexCandidate({ repoFullName: "acme/widgets", issueNumber: 1, title: "t", assignees: ["acme", "  ", 42, " maintainer "] })?.assignees,
+      ).toEqual(["acme", "maintainer"]);
+      // Explicitly served empty: present as [] (a real "no assignees" signal).
+      expect(normalizeDiscoveryIndexCandidate({ repoFullName: "acme/widgets", issueNumber: 1, title: "t", assignees: [] })?.assignees).toEqual([]);
+      // Never served (older server build): the field is omitted, so a client can tell it apart from served-empty
+      // and fall back to [] at the merge site rather than silently skipping the repo-owner exclusion filter.
+      expect("assignees" in (normalizeDiscoveryIndexCandidate({ repoFullName: "acme/widgets", issueNumber: 1, title: "t" }) ?? {})).toBe(false);
+    });
+
     it("maps aiPolicySource and respects an explicit aiPolicyAllowed:false", () => {
       expect(normalizeDiscoveryIndexCandidate({ repoFullName: "o/r", issueNumber: 1, title: "t", aiPolicySource: "CONTRIBUTING.md", aiPolicyAllowed: false })).toMatchObject({
         aiPolicySource: "CONTRIBUTING.md",

test/unit/discovery-index-contract.test.ts

@@ -82,6 +82,26 @@ function fanOutIssue(overrides: Record<string, unknown> = {}) {
   };
 }
 
+// A hosted discovery-index candidate (#7168 shape). assignees is optional in the contract (#7442) — omit it to
+// simulate an older server build that never populated the field.
+function indexCandidate(overrides: Record<string, unknown> = {}) {
+  return {
+    owner: "acme",
+    repo: "widgets",
+    repoFullName: "acme/widgets",
+    issueNumber: 2,
+    title: "index-sourced issue",
+    labels: ["help wanted"],
+    commentsCount: 0,
+    createdAt: null,
+    updatedAt: null,
+    htmlUrl: null,
+    aiPolicyAllowed: true as const,
+    aiPolicySource: "none" as const,
+    ...overrides,
+  };
+}
+
 afterEach(() => {
   for (const store of stores.splice(0)) store.close();
   closeDefaultPortfolioQueueStore();
@@ -469,6 +489,67 @@ describe("runDiscover (#4247)", () => {
     ]);
   });
 
+  it("REGRESSION (#7442): a discovery-index candidate assigned to its own repo owner is excluded once real assignees flow through", async () => {
+    const portfolioQueue = tempQueueStore();
+    const fetchCandidateIssuesWithSummary = vi.fn(async () => ({
+      issues: [fanOutIssue({ issueNumber: 1, title: "direct fan-out issue" })],
+      warnings: [],
+      rateLimitRemaining: 5000,
+      rateLimitResetAt: "2026-07-09T13:00:00.000Z",
+    }));
+    // The hosted index supplies a DIFFERENT issue (so it survives dedupe) assigned to the repo owner "acme".
+    const queryDiscoveryIndex = vi.fn(async () => ({ contractVersion: 1, candidates: [indexCandidate({ issueNumber: 2, assignees: ["acme"] })], nextCursor: null }));
+
+    const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const exitCode = await runDiscover(["acme/widgets", "--json"], {
+      nowMs: NOW,
+      env: { ...process.env, LOOPOVER_MINER_DISCOVERY_PLANE: "1" },
+      initPortfolioQueue: () => portfolioQueue,
+      initPolicyDocCache: () => tempPolicyDocCacheStore(),
+      initPolicyVerdictCache: () => tempPolicyVerdictCacheStore(),
+      initRankedCandidatesStore: () => tempRankedCandidatesStore(),
+      fetchCandidateIssuesWithSummary,
+      queryDiscoveryIndex: queryDiscoveryIndex as never,
+    });
+
+    expect(exitCode).toBe(0);
+    expect(queryDiscoveryIndex).toHaveBeenCalled();
+    const payload = JSON.parse(String(log.mock.calls[0]?.[0]));
+    // The owner-assigned index candidate (issue 2) is excluded by the #7040 filter; only the direct fan-out issue survives.
+    expect(payload.ranked.map((e: { issueNumber: number }) => e.issueNumber)).toEqual([1]);
+    expect(portfolioQueue.listQueue("acme/widgets").map((e) => e.identifier)).toEqual(["issue:1"]);
+  });
+
+  it("REGRESSION (#7442): a discovery-index response that omits assignees falls back to [] and still runs the filter (kept, not skipped)", async () => {
+    const portfolioQueue = tempQueueStore();
+    const fetchCandidateIssuesWithSummary = vi.fn(async () => ({
+      issues: [fanOutIssue({ issueNumber: 1, title: "direct fan-out issue" })],
+      warnings: [],
+      rateLimitRemaining: 5000,
+      rateLimitResetAt: "2026-07-09T13:00:00.000Z",
+    }));
+    // Older server build: the candidate carries NO assignees field at all.
+    const queryDiscoveryIndex = vi.fn(async () => ({ contractVersion: 1, candidates: [indexCandidate({ issueNumber: 2 })], nextCursor: null }));
+
+    const log = vi.spyOn(console, "log").mockImplementation(() => undefined);
+    const exitCode = await runDiscover(["acme/widgets", "--json"], {
+      nowMs: NOW,
+      env: { ...process.env, LOOPOVER_MINER_DISCOVERY_PLANE: "1" },
+      initPortfolioQueue: () => portfolioQueue,
+      initPolicyDocCache: () => tempPolicyDocCacheStore(),
+      initPolicyVerdictCache: () => tempPolicyVerdictCacheStore(),
+      initRankedCandidatesStore: () => tempRankedCandidatesStore(),
+      fetchCandidateIssuesWithSummary,
+      queryDiscoveryIndex: queryDiscoveryIndex as never,
+    });
+
+    expect(exitCode).toBe(0);
+    const payload = JSON.parse(String(log.mock.calls[0]?.[0]));
+    // Fail-safe: the omitted field becomes [], the owner-exclusion filter still runs (finds no assignment), issue 2 is KEPT.
+    expect(payload.ranked.map((e: { issueNumber: number }) => e.issueNumber).sort()).toEqual([1, 2]);
+    expect(portfolioQueue.listQueue("acme/widgets").map((e) => e.identifier).sort()).toEqual(["issue:1", "issue:2"]);
+  });
+
   it("#4847: --dry-run performs the real fan-out/rank but never opens any local store", async () => {
     const initPortfolioQueue = vi.fn();
     const initPolicyDocCache = vi.fn();