test(graph): follow the reviewed-schema contract in the live pipeline test and the G1 explorer spec

Two lanes that only run against the paid gateway had drifted from the Task 7/8
contracts and surfaced once the key limit was raised:

- tests/integration/test_graphrag_pipeline_live.py built the semantic pipeline
  without the route upstream (D25) and the extraction template (D24) the factory
  now requires; it passes both, resolved the way the index job does.
- web/tests/e2e/exhaustive/curious_user_p1_fixes.spec.ts (G1/G2/G3) indexed a
  semantic corpus without a reviewed schema (409 graph_schema_approval_required
  since Task 8), expected the label-propagation community ids retired by Task 7's
  GDS Leiden cut, and searched the fullscreen canvas for the closed-vocabulary
  palette retired by D1. It now derives and approves the proposal through the
  same endpoint the Indexing page uses (indexCorpus takes the approved hash),
  expects Leiden's integer community ids, requires the legend to name the
  reviewed schema's labels, and reads node colours from the legend's swatches.

Verification (LXC100 overlay against the deployed eec26d4): pipeline live
suite 4 passed; the G1/G2/G3 spec 1 passed in 50 s after failing on each stale
expectation in turn; ruff and tsc clean.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_016TSkfA3Bn57dRokmK22MkE

Author: DMontgomery40

tests/integration/test_graphrag_pipeline_live.py

@@ -24,7 +24,7 @@
 from server.config import load_config
 from server.db.neo4j import Neo4jClient
 from server.db.postgres import PostgresClient
-from server.gateway_catalog import warm_gateway_catalog
+from server.gateway_catalog import gateway_upstream_for_alias, warm_gateway_catalog
 from server.indexing.generations import GenerationManifest
 from server.indexing.graphrag_pipeline import (
     GraphScopeCollisionError,
@@ -137,9 +137,11 @@ async def test_semantic_and_code_files_use_scoped_official_writer_contract(
             route_model=str(route.model or ""),
             route_base_url=str(route.base_url or ""),
             route_api_key=str(route.api_key or ""),
+            route_upstream=gateway_upstream_for_alias(str(route.model or "")),
             max_concurrency=2,
             llm_timeout_s=int(cfg.graph_indexing.semantic_kg_llm_timeout_s),
             reasoning_effort=str(cfg.graph_indexing.semantic_kg_reasoning_effort),
+            prompt_template=str(cfg.system_prompts.semantic_kg_extraction),
         )
         semantic_chunks = [
             Chunk(

web/tests/e2e/exhaustive/corpus_fixture.ts

@@ -93,11 +93,18 @@ export async function indexCorpus(
   request: APIRequestContext,
   corpusId: string,
   corpusPath: string,
-  opts: { timeoutMs?: number } = {}
+  opts: { timeoutMs?: number; approvedGraphSchemaHash?: string } = {}
 ): Promise<void> {
   const timeoutMs = opts.timeoutMs ?? INDEX_TIMEOUT_MS;
+  // A semantic-policy corpus indexes only against its reviewed schema hash (Task 8);
+  // callers that derived a proposal pass it through, everything else stays as before.
   const started = await request.post(`${API_BASE}/index`, {
-    data: { corpus_id: corpusId, repo_path: corpusPath, force_reindex: true },
+    data: {
+      corpus_id: corpusId,
+      repo_path: corpusPath,
+      force_reindex: true,
+      ...(opts.approvedGraphSchemaHash ? { approved_graph_schema_hash: opts.approvedGraphSchemaHash } : {}),
+    },
   });
   if (!started.ok()) await failWithBody(`POST /api/index for ${corpusId}`, started);
   const deadline = Date.now() + timeoutMs;

web/tests/e2e/exhaustive/curious_user_p1_fixes.spec.ts

@@ -223,6 +223,8 @@ test.describe.serial('G1/G2/G3 on a semantic graph corpus provisioned by the sui
   // pre-existing corpus, so the graph assertions can never skip.
   let graphCorpus: ExhaustiveCorpus;
   let graphCorpusId = '';
+  /** Node labels of the reviewed schema the run indexed against (the legend must show these). */
+  let approvedNodeLabels: string[] = [];
 
   test.beforeAll(async ({ request }) => {
     test.setTimeout(10 * 60 * 1000);
@@ -233,7 +235,21 @@ test.describe.serial('G1/G2/G3 on a semantic graph corpus provisioned by the sui
       build_code_graph: false,
       semantic_kg_llm_model: EXHAUSTIVE_CHAT_MODEL,
     });
-    await indexCorpus(request, graphCorpusId, graphCorpus.corpusPath);
+    // Semantic indexing runs only against a reviewed schema (Task 8): derive the proposal
+    // the way the operator does on the Indexing page and approve its exact hash.
+    const proposalRes = await request.post(`${API_BASE}/index/${encodeURIComponent(graphCorpusId)}/graph-schema/proposal`, {
+      data: { force_refresh: false },
+    });
+    expect(proposalRes.ok(), await proposalRes.text()).toBeTruthy();
+    const proposal = (await proposalRes.json()) as {
+      schema_hash: string;
+      schema?: { node_types?: Array<{ label: string }> };
+      schema_payload?: { node_types?: Array<{ label: string }> };
+    };
+    expect(proposal.schema_hash).toMatch(/^[0-9a-f]{64}$/);
+    approvedNodeLabels = ((proposal.schema ?? proposal.schema_payload)?.node_types ?? []).map((n) => n.label);
+    expect(approvedNodeLabels.length, 'the reviewed schema names at least one node type').toBeGreaterThan(0);
+    await indexCorpus(request, graphCorpusId, graphCorpus.corpusPath, { approvedGraphSchemaHash: proposal.schema_hash });
     const stats = await (await request.get(`${API_BASE}/graph/${encodeURIComponent(graphCorpusId)}/stats`)).json();
     expect(stats.total_entities, 'semantic extraction must produce entities').toBeGreaterThan(0);
     expect(stats.total_relationships, 'semantic extraction must produce relationships').toBeGreaterThan(0);
@@ -253,7 +269,9 @@ test.describe.serial('G1/G2/G3 on a semantic graph corpus provisioned by the sui
     const ids = await communities.evaluateAll((els) => els.map((el) => el.getAttribute('data-testid') || ''));
     expect(ids.length).toBeGreaterThan(1);
     for (const id of ids) {
-      expect(id).toMatch(/^graph-community-c-[0-9a-f]{12}$/);
+      // Communities are GDS Leiden partitions since Task 7 (integer communityId), not the
+      // label-propagation hashes the 2026-08-25 fix wave named `c-<12 hex>`.
+      expect(id).toMatch(/^graph-community-\d+$/);
       expect(id).not.toContain('__staging__');
       expect(id).not.toContain('(root)');
     }
@@ -290,8 +308,15 @@ test.describe.serial('G1/G2/G3 on a semantic graph corpus provisioned by the sui
     expect(sizes.canvasW, 'fullscreen canvas fills the modal width').toBeGreaterThan(sizes.modalW - 4);
     expect(sizes.canvasH, 'fullscreen canvas fills the modal height').toBeGreaterThan(sizes.hostH - 4);
     expect(sizes.headerText).toMatch(/\d+ nodes • [1-9]\d* edges/);
+    // Entity types are the reviewed schema's labels since Task 8 (D1), not a closed
+    // vocabulary; the legend lists them and never the code policy's kinds.
     const legend = page.getByTestId('graph-fullscreen-legend');
-    await expect(legend).toContainText('concept');
+    const legendText = (await legend.innerText()).trim();
+    expect(legendText.length).toBeGreaterThan(0);
+    expect(
+      approvedNodeLabels.some((label) => legendText.includes(label)),
+      `legend "${legendText}" names none of the reviewed labels ${approvedNodeLabels.join(', ')}`,
+    ).toBe(true);
     await expect(legend).not.toContainText('function');
 
     // G3: scroll-zoom changes the zoom transform AND repaints; clicking a node selects it.
@@ -321,21 +346,24 @@ test.describe.serial('G1/G2/G3 on a semantic graph corpus provisioned by the sui
     expect(k1! > k0!, `wheel must zoom in (k ${k0} -> ${k1})`).toBeTruthy();
     expect(h1, 'the canvas must repaint after zoom').not.toBe(h0);
 
-    // Find a painted node (person = #f97316 / org = #0ea5e9) and click it.
+    // Find a painted node and click it. Node colours belong to the reviewed schema's
+    // labels (D1), so the targets are read from the legend's own swatches rather than a
+    // fixed palette.
     const nodePoint = await page.evaluate(() => {
       const canvas = document.querySelector('[data-testid="graph-fullscreen-canvas"] canvas') as HTMLCanvasElement;
       const rect = canvas.getBoundingClientRect();
       const scaleX = canvas.width / rect.width;
       const scaleY = canvas.height / rect.height;
       const data = canvas.getContext('2d')!.getImageData(0, 0, canvas.width, canvas.height).data;
-      // person, org, location, event, concept — the visualizer's node palette.
-      const targets = [
-        [249, 115, 22],
-        [14, 165, 233],
-        [16, 185, 129],
-        [234, 179, 8],
-        [148, 163, 184],
-      ];
+      const swatches = Array.from(
+        document.querySelectorAll('[data-testid="graph-fullscreen-legend"] span span'),
+      ) as HTMLElement[];
+      const targets: number[][] = [];
+      for (const swatch of swatches) {
+        const match = getComputedStyle(swatch).backgroundColor.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+        if (match) targets.push([Number(match[1]), Number(match[2]), Number(match[3])]);
+      }
+      if (targets.length === 0) return null;
       for (let y = Math.floor(canvas.height * 0.12); y < canvas.height * 0.88; y += 2) {
         for (let x = Math.floor(canvas.width * 0.05); x < canvas.width * 0.95; x += 2) {
           const i = (y * canvas.width + x) * 4;