feat(ms-ai-architect): C3.3 — course_products (live-enumerert) + makeCourseClassifier (TDD) [skip-docs]

Produkt-slug->kategori-mapping for kurs-deteksjon (C3.3 av GODKJENT C3-spec).

- lib/taxonomy.mjs: makeCourseClassifier(tax) — speiler makeClassifier; forste
  in-domain produkt vinner; skill AVLEDES fra category_skill (lagres ALDRI i
  course_products -> kan ikke divergere); ukjent/tom/non-array -> null.
- data/domain-taxonomy.json: ny topp-niva course_products (slug->category) +
  provenance. 15 in-domain live slugs.
- test-taxonomy.test.mjs (+6): atferd (in-domain->{skill,category}, first-wins,
  out-of-domain/tom/non-array->null, manglende map) + REELL data-invariant
  (hver slug-kategori resolver til skill, derivasjon matcher) + azure-openai-live.

ENUMERERING (gotcha #2, live mot /api/v1/modules?products=<slug> server-side):
- DOD (0 treff): azure-ai-foundry, ai-services, azure-ai-services, foundry ->
  Foundry/AI-services-kurs dukker opp under 'azure-openai'.
- Slug-feller bekreftet live: 'fabric' (ikke microsoft-fabric), 'entra' (ikke
  microsoft-entra-id), 'azure-cosmos-db' (ikke cosmos-db), 'azure-cognitive-search'
  (ikke azure-ai-search).
- 'azure-kubernetes-service' live men EKSKLUDERT (ingen AI-kategori -> stoy).
- Inkluderte (15): azure-openai, azure-machine-learning, azure-cognitive-search,
  azure-cosmos-db, fabric, azure-databricks, microsoft-copilot-studio,
  power-automate, power-apps, power-platform, ai-builder, microsoft-365-copilot,
  microsoft-purview, entra, defender-for-cloud.

Avvik fra spec 4.4-eksempel: course_products lagrer slug->category (ikke
slug->{skill,category}); skill avledes — anti-divergens, encapsulated av
makeCourseClassifier (downstream-kontrakt {skill,category} uendret).

Gate 7 C3.3 mott: test gronn, eval --json IDENTISK (refTall/K-counts uendret).
kb-update 263->269, validate PASSED (239/0), null regresjon.

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

tests/kb-update/test-taxonomy.test.mjs

@@ -16,6 +16,7 @@ import {
   getSitemapPrefixes,
   getCategorySkill,
   makeClassifier,
+  makeCourseClassifier,
   makePriorityFn,
   applyCategoryReassignments,
 } from '../../scripts/kb-update/lib/taxonomy.mjs';
@@ -165,3 +166,69 @@ test('saveTaxonomy + loadTaxonomy — atomic round-trip preserves content', () =
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+// --- (f) makeCourseClassifier (C3.3) — product-slug → {skill, category} ---
+// course_products maps an in-domain Learn product slug → category; the owning
+// skill is DERIVED from category_skill (never stored redundantly), mirroring
+// makeClassifier's anti-divergence rule. First in-domain product wins; a course
+// whose products are all out-of-domain returns null (not a lead).
+
+// Synthetic taxonomy isolates the classifier's behaviour from the real data.
+const courseTax = {
+  category_skill: {
+    'azure-ai-services': 'ms-ai-engineering',
+    'platforms': 'ms-ai-advisor',
+  },
+  course_products: {
+    'azure-openai': 'azure-ai-services',
+    'microsoft-copilot-studio': 'platforms',
+    'power-automate': 'platforms',
+  },
+};
+
+test('makeCourseClassifier — in-domain slug → derived {skill, category}', () => {
+  const classify = makeCourseClassifier(courseTax);
+  assert.deepEqual(classify(['azure-openai']), { skill: 'ms-ai-engineering', category: 'azure-ai-services' });
+  assert.deepEqual(classify(['microsoft-copilot-studio']), { skill: 'ms-ai-advisor', category: 'platforms' });
+});
+
+test('makeCourseClassifier — first in-domain product wins (order matters)', () => {
+  const classify = makeCourseClassifier(courseTax);
+  // a leading out-of-domain slug is skipped; first in-domain wins
+  assert.deepEqual(classify(['some-unknown-product', 'azure-openai']), { skill: 'ms-ai-engineering', category: 'azure-ai-services' });
+  // when two in-domain products are present, the FIRST in the list wins
+  assert.deepEqual(classify(['azure-openai', 'power-automate']), { skill: 'ms-ai-engineering', category: 'azure-ai-services' });
+  assert.deepEqual(classify(['power-automate', 'azure-openai']), { skill: 'ms-ai-advisor', category: 'platforms' });
+});
+
+test('makeCourseClassifier — out-of-domain / empty / non-array → null', () => {
+  const classify = makeCourseClassifier(courseTax);
+  assert.equal(classify(['totally-unknown', 'another-unknown']), null, 'all out-of-domain → null');
+  assert.equal(classify([]), null, 'empty products → null');
+  assert.equal(classify(null), null, 'non-array input → null (defensive)');
+  assert.equal(classify(undefined), null, 'undefined input → null (defensive)');
+});
+
+test('makeCourseClassifier — taxonomy without course_products → always null', () => {
+  const classify = makeCourseClassifier({ category_skill: {} });
+  assert.equal(classify(['azure-openai']), null, 'absent course_products map → no lead');
+});
+
+// --- (g) REAL course_products invariant (C3.3 data, enumerated from live API) ---
+test('INVARIANT — every course_products category resolves to a skill, derivation matches', () => {
+  assert.ok(tax.course_products, 'course_products section present in domain-taxonomy.json');
+  assert.ok(Object.keys(tax.course_products).length > 0, 'course_products is non-empty');
+  const classify = makeCourseClassifier(tax);
+  for (const [slug, category] of Object.entries(tax.course_products)) {
+    assert.equal(typeof category, 'string', `${slug} maps to a category string`);
+    const skill = getCategorySkill(tax, category);
+    assert.ok(skill, `course_products slug ${slug} → category ${category} absent from category_skill`);
+    assert.deepEqual(classify([slug]), { skill, category }, `divergence for slug ${slug}`);
+  }
+});
+
+test('makeCourseClassifier — azure-openai (verified-live slug) → engineering/azure-ai-services', () => {
+  // azure-openai is the empirically-confirmed live slug (spike §: 34 hits).
+  const classify = makeCourseClassifier(tax);
+  assert.deepEqual(classify(['azure-openai']), { skill: 'ms-ai-engineering', category: 'azure-ai-services' });
+});