fix(adapter-github): stable tiebreaker for language-distribution ranking (#23)

computeLanguageDistribution sorted language counts descending then
`.slice(0, 5)`, but ties on count fell back to Map insertion order (the
GitHub repo API response order). With the top-5 cutoff, a tie at the
boundary changed which language landed in the profile — and that result
flows into buildProfileEvidence → scoring, so output could differ across
runs for the same input. Third instance of the #10 / #19 pattern.

Add a final localeCompare tiebreaker before the slice so equal-count
languages sort deterministically.

Test mirrors #19 / H-10: Java and Ruby tie at count 1 straddling the top-5
boundary (Ruby listed first so the unshuffled order wrongly picks it),
shuffled via deterministic LCG across 100 seeds, asserting an identical
top-5 every time. Verified RED before the fix, GREEN after.

Verification: adapter-github 38/38, full suite 794 passing / 1 skipped,
lint 14/14, typecheck 27/27, build 14/14.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: matthewod11-stack

packages/adapters/adapter-github/src/__tests__/github-adapter.test.ts

@@ -449,6 +449,63 @@ describe('extractEmailsFromCommits (H-10 follow-up: stable tiebreaker)', () => {
   });
 });
 
+describe('computeLanguageDistribution (H-10 follow-up: stable tiebreaker, #23)', () => {
+  // LCG-based shuffle so test outcome is reproducible (mirrors the H-10 test).
+  function deterministicShuffle<T>(arr: readonly T[], seed: number): T[] {
+    const a = [...arr];
+    let s = seed >>> 0;
+    for (let i = a.length - 1; i > 0; i--) {
+      s = (s * 1103515245 + 12345) >>> 0;
+      const j = s % (i + 1);
+      [a[i], a[j]] = [a[j], a[i]];
+    }
+    return a;
+  }
+
+  function makeLangRepo(language: string) {
+    return {
+      name: `r-${language}`,
+      stargazers_count: 0,
+      fork: false,
+      full_name: `u/r-${language}`,
+      language,
+      forks_count: 0,
+      topics: [],
+      updated_at: '2026-01-01T00:00:00Z',
+      pushed_at: '2026-01-01T00:00:00Z',
+      html_url: 'https://github.com/u/r',
+    };
+  }
+
+  it('produces identical top-5 languages across 100 shuffles when counts tie at the boundary', () => {
+    // Java and Ruby tie at count 1, straddling the top-5 cutoff. Ruby is listed
+    // first so that without a tiebreaker the unshuffled order would (wrongly)
+    // pick Ruby; the repo API response order would then flip it run to run.
+    const repos = [
+      ...Array.from({ length: 5 }, () => makeLangRepo('TypeScript')),
+      ...Array.from({ length: 4 }, () => makeLangRepo('Python')),
+      ...Array.from({ length: 3 }, () => makeLangRepo('Go')),
+      ...Array.from({ length: 2 }, () => makeLangRepo('Rust')),
+      makeLangRepo('Ruby'),
+      makeLangRepo('Java'),
+    ];
+
+    const expected = computeLanguageDistribution(repos as GitHubRepo[]).map(
+      (s) => s.language,
+    );
+    // localeCompare ascending → 'Java' beats 'Ruby' for the 5th slot.
+    expect(expected).toEqual(['TypeScript', 'Python', 'Go', 'Rust', 'Java']);
+
+    for (let seed = 1; seed <= 100; seed++) {
+      const shuffled = deterministicShuffle(repos, seed);
+      const result = computeLanguageDistribution(shuffled as GitHubRepo[]).map(
+        (s) => s.language,
+      );
+      expect(result).toEqual(expected);
+    }
+  });
+});
+
 describe('GitHubClient API contract validation (H-11)', () => {
   it('throws ApiContractError with the missing field path', async () => {
     mockFetch.mockImplementation(async () => ({

packages/adapters/adapter-github/src/parsers.ts

@@ -84,7 +84,12 @@ export function computeLanguageDistribution(
   }
 
   return [...counts.entries()]
-    .sort((a, b) => b[1] - a[1])
+    .sort((a, b) => {
+      if (b[1] !== a[1]) return b[1] - a[1]; // higher count first
+      // Deterministic tiebreaker before the top-5 cutoff so equal-count
+      // languages can't flip in/out of the profile with repo API order (#23).
+      return a[0].localeCompare(b[0]);
+    })
     .slice(0, 5)
     .map(([language, count]) => ({
       language,