merge(feat): 2.4.2 Galaxy feel + Group hue

.agents/skills/dev-protocol/lessons-learned.md

@@ -34,6 +34,11 @@ Este archivo registra las lecciones aprendidas, invariantes de arquitectura y pa
 - **Invariante**: Si reaparece oscurecido al mover cámara en RIBBONS, revisar fog **antes** que normales/luces. PR aparte: solapamiento por `depthWrite: false` en ribbons.
 - **Seguimiento**: RIBBONS ya no monta `basePlane`. Compare+RIBBONS no monta POINTS (bug: `else if (pointsData.length)` atrapaba RIBBONS). `depthWrite` / opacidad de wide ribbons → si reaparece solapamiento al orbitar.
 
+### 1.3b. Galaxy soft-star POINTS (opt-in)
+- **Problema**: Square Chebyshev `gl_PointCoord` mask looks tiled when Galaxy points are dense/small.
+- **Solución**: Soft-star path (`resolvePointEdgeStyle` / `galaxy: true`) — solid circular core + soft halo; higher size attenuation with smaller clamp. ANALYSIS/NAV keep §1.3 / §1.5 squares.
+- **Invariante**: only Galaxy POINTS; `frustumCulled = false` unchanged.
+
 ### 1.3. Renderizado de Puntos Sólidos y Definidos (Sin Halos Esfumados)
 - **Problema**: Un gradiente suave amplio de `smoothstep(0.0, 0.5, dist)` genera puntos borrosos, translúcidos y "esfumados".
 - **Solución Obligatoria**: Renderizar discos sólidos con un borde de anti-aliasing ultra-definido de 1 píxel:
@@ -118,6 +123,8 @@ User-editable hex anchors replace the former fixed dual ramp (no product mid-sto
 - **Patrón**: Proyectar los orígenes 3D ($X=0$) de los hilos vectoriales a coordenadas 2D de pantalla (`vector.project(camera)`) para renderizar cartelitos Glassmorphic anclados al inicio de cada hilo.
 - **Invariante**: En el modo **Análisis**, los hilos se apilan verticalmente a lo largo de $Y$ con encuadre frontal directo (`Z=360`), permitiendo visualizar todos los componentes y el resultado inmediatamente sin desplazamientos manuales.
 
+- **Invariante**: ANALYSIS/NAV flight numbers unchanged; no Spatial speed knobs in v1.
+
 ### 3.5. Touch mobile: joystick/look no roban eventos de docks/HUD
 - **Problema**: Pointers que empiezan en drawers/Compare/HUD mueven la cámara o pelean con scroll.
 - **Solución Obligatoria**: Look solo si `target` es `CANVAS` y no hace match de docks/HUD/joystick (`isUiTouchTarget`). Joystick y botones Q/E escriben ejes en `Navigation` (`setMoveAxes` / `setVertical`); el update sigue el mismo `lerp` §3.1. Desktop mouse/WASD intacto.
@@ -134,6 +141,11 @@ User-editable hex anchors replace the former fixed dual ramp (no product mid-sto
 - **Overlay de captura**: El HUD `CAM POSE` solo se monta si `VITE_SHOW_CAM_POSE=true` (default `false` en `.env.example`).
 - **Workflow de captura**: Activar overlay → navegar a la pose → screenshot POS/ROT → actualizar `CAMERA_DEFAULT_OVERRIDES` y/o `SPATIAL_DEFAULT_OVERRIDES` para la clave `MODE|VIEW|RENDER`.
 
+### 3.6. Galaxy flight profile (VIEW-only)
+- **Problema**: UMAP world + default `moveSpeed` 75 / look `0.003` felt cramped and twitchy in Galaxy.
+- **Solución**: `galaxyFlightProfile.js` — apply on enter Galaxy, restore defaults on leave. Calibrated: `moveSpeed` 56 (former Shift feel), `turboMultiplier` 2, `lookSensitivity` 0.0014. World scale via `resolveGalaxyWorldScale` (`GALAXY_DEFAULT_SCALE` 96, spacing×240).
+- **Invariante**: ANALYSIS/NAV flight numbers unchanged; no Spatial speed knobs in v1.
+
 ---
 
 ## 4. UI Panels (Sidebar / Compare)
@@ -260,6 +272,11 @@ Portable findings from VHectorLab 3D `v2.1.0` — apply if the older app shares
 - **Solución**: Deep module `groupDimContrast.js` — means raw G1↔G2; `sim = 1−|Δ|/(|a|+|b|)`; cancel ZC-style sobre metric alta → negro; opposite → highlight color × strength×diff + conflict coverage independiente. Solo paint (Y intacto). UI gated (`setGroupContrastControlsEnabled`) hasta ≥2 grupos.
 - **Invariante**: Zero coverage global y Group contrast son independientes; On habilita sliders (Off = grisado); shader POINTS usa `aCancel`/`aHighlight` + `uColorHighlight`.
 
+### 4.11c. Group hue (per-group black → color)
+- **Problema**: Rampa divergente global no distingue dominios `GROUP_*` en Galaxy/Compare.
+- **Solución**: Toggle `groupHueEnabled` + map `groupHueColors`; base = lerp(black, groupHex, remapped t) when ON (`groupHuePaint.js`); POINTS via `aBaseColor` + `uUseGroupHueBase`; RIBBONS via CPU `colorForActivationWithGroupHue`. Zero coverage remaps \|t\| then black↔color. Missing `groupId` → divergent fallback.
+- **Invariante**: Shared noise / Sign conflict still apply after base; default OFF; gate ≥2 groups; persist under `vl3d.viz.*`.
+
 ### 4.12. Bottom HUD hover activation (POINTS / RIBBONS)
 - **Problema**: `ACTIVATION` siempre `0.0000` — `Interaction` pasaba `userData` del mesh (`{ pointsData }`), y el HUD leía `userData.val` / `data.activation` (inexistentes).
 - **Solución Obligatoria**: Resolver vía `resolveHoverTelemetry` → `pointsData[index].activation` (POINTS) o `userData.activations` + face/`index` (RIBBONS / continuity). Formatear con `formatActivationValue` (hasta 32 decimales, shrink + scientific si el slot es angosto; label `ACT:` en mobile). `title` tooltip con valor completo.

CHANGELOG.md

@@ -4,6 +4,16 @@ All notable changes to VHectorLab 3D will be documented in this file.
 
 ## [Unreleased]
 
+## [2.4.2] - 2026-08-08
+
+### Added
+- **Galaxy feel**: larger UMAP world (`GALAXY_DEFAULT_SCALE` 96, spacing×240) + Galaxy-only flight profile (cruise 56, Shift ×2, softer look); leave Galaxy restores ANALYSIS/NAV speeds.
+- **Galaxy soft stars**: circular solid core + soft halo POINTS (ANALYSIS/NAV squares unchanged).
+- **Group hue** (Visualization → Group contrast): per-`GROUP_*` black (−1) → picked color (+1); default OFF; transversal COMPARE paint (POINTS + RIBBONS); Shared noise / Sign conflict still layer on top.
+
+### Changed
+- Workbench value fields (`input` / `textarea` / `select`): dark fill `#1a1a1a` instead of white (color/range/checkbox unchanged).
+
 ## [2.4.1] - 2026-08-08
 
 ### Added

CONTEXT.md

@@ -62,7 +62,13 @@ Percent of the |t| range held at the zero color (default black) before blending
 Visualization paint for Compare with ≥2 groups: **Shared noise** blackens same-sign dims by similarity; **Sign conflict** highlights opposite-sign dims (custom color × |Δ|) and can blacken them by difference. Uses group means on raw embeddings; geometry Y unchanged.
 
 ### Workbench Theme
-Default product chrome at `/`: Magic Workbench–inspired palette, Topaz typography, and bevelled panels on the fullscreen + floating-dock layout. Tunable via `VITE_AMIGA_*` in `.env`. Product name remains **VHectorLab 3D**.
+Default product chrome at `/`: Magic Workbench–inspired palette, Topaz typography, and bevelled panels on the fullscreen + floating-dock layout. Tunable via `VITE_AMIGA_*` in `.env`. Product name remains **VHectorLab 3D**. Value fields use dark fills (not white).
+
+### Galaxy feel
+Galaxy VIEW uses a larger UMAP world scale and a slower flight profile (WASD/QE + mouse look) than ANALYSIS/NAVIGATION; leaving Galaxy restores default speeds. Galaxy POINTS render as soft circular stars.
+
+### Group hue
+Optional Visualization → Group contrast mode: each `GROUP_*` paints black (−1) → a picked color (+1), coexisting with Shared noise / Sign conflict. Default OFF.
 
 _Avoid_: parallel MPA skins (`/v25/`, `/amiga/` — retired in 2.4.1); multi-zone lab grids as the primary layout.
 

backend/server.py

@@ -51,7 +51,7 @@ async def lifespan(app: FastAPI):
 app = FastAPI(
     title="VHectorLab 3D API",
     description="Backend API for 3D Vector Arithmetic & Semantic Embedding Visualizer",
-    version="2.4.1",
+    version="2.4.2",
     lifespan=lifespan,
 )
 

manifest.json

@@ -1,6 +1,6 @@
 {
   "project": "vhectorlab-3d",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "bootstrap_run": false,
   "state_schema": {
     "model_name": "all-mpnet-base-v2",

package.json

@@ -1,6 +1,6 @@
 {
   "name": "vhectorlab-3d",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "type": "module",
   "scripts": {
     "dev": "vite",

roadmap/galaxy-feel-group-hue.md

@@ -1,6 +1,6 @@
 # Roadmap — Galaxy feel + Group hue paint
 
-**Status:** Plan (ready to implement)  
+**Status:** Shipped (2.4.2)  
 **Date:** 2026-08-08  
 **Product:** VHectorLab 3D — **legacy UI only** (`/`, `src/main.js`). **Do not touch `src/v25/`.**  
 **Prompt companion:** [`PROMPT-galaxy-feel-group-hue.md`](./PROMPT-galaxy-feel-group-hue.md)  

src/engine/galaxyFlightProfile.js

@@ -13,12 +13,12 @@ export const DEFAULT_FLIGHT_PROFILE = Object.freeze({
 });
 
 /**
- * Galaxy-only: slower cruise + softer look so a larger UMAP world feels elegant.
- * Calibrated with GALAXY_DEFAULT_SCALE ≈ 96 (RMS≈1 → ~several seconds across IT-core).
+ * Galaxy-only: cruise = former Shift speed; Shift = 2× that (incremental).
+ * Look stays soft vs ANALYSIS/NAV. Calibrated with GALAXY_DEFAULT_SCALE ≈ 96.
  */
 export const GALAXY_FLIGHT_PROFILE = Object.freeze({
-  moveSpeed: 32.0,
-  turboMultiplier: 1.75,
+  moveSpeed: 56.0, // was 32 × 1.75 (previous turbo feel)
+  turboMultiplier: 2.0,
   lookSensitivity: 0.0014,
 });
 

src/main.js

@@ -663,7 +663,15 @@ class VHectorLabApp {
     const items = state.workspaceMode === 'COMPARE'
       ? (this.rawCompareData?.items || state.compareData?.items || [])
       : [];
-    setGroupContrastControlsEnabled(this.vizEl, hasGroupsForDimContrast(items), this.vizConfig);
+    const groupIds = [...new Set(
+      (items || []).map((it) => it?.groupId).filter(Boolean),
+    )];
+    setGroupContrastControlsEnabled(
+      this.vizEl,
+      hasGroupsForDimContrast(items),
+      this.vizConfig,
+      groupIds,
+    );
   }
 
   /**

src/style.css

@@ -1532,6 +1532,7 @@ canvas {
 }
 
 #visualization-controls-container .viz-fx-slider.is-inert,
+#visualization-controls-container .viz-group-hue-rows.is-inert,
 #visualization-controls-container .viz-group-contrast.is-disabled {
   opacity: 0.45;
 }

src/theme/chrome.css

@@ -131,17 +131,25 @@ body.workbench-theme .dock-tab {
   border-radius: 0 !important;
 }
 
-body.workbench-theme input,
+/* Value fields — dark fills (white burned eyes on Workbench chrome) */
+body.workbench-theme input:not([type="checkbox"]):not([type="radio"]):not([type="range"]):not([type="color"]):not([type="button"]):not([type="submit"]):not([type="reset"]),
 body.workbench-theme textarea,
 body.workbench-theme select {
-  background: var(--mwb-white) !important;
+  background: #1a1a1a !important;
   color: var(--amiga-fg) !important;
   border: 2px solid var(--mwb-black) !important;
   border-radius: 0 !important;
-  box-shadow: inset 2px 2px 0 var(--mwb-halfshadow) !important;
+  box-shadow: inset 2px 2px 0 #0d0d0d !important;
+  caret-color: #c8c8c8;
+}
+
+body.workbench-theme input:not([type="checkbox"]):not([type="radio"]):not([type="range"]):not([type="color"])::placeholder,
+body.workbench-theme textarea::placeholder {
+  color: #7a7a7a !important;
+  opacity: 1;
 }
 
-/* Compare token editor — black field, muted (darker) text */
+/* Compare token editor — pure black field, muted text */
 body.workbench-theme #compare-panel #compare-tokens {
   background: #000000 !important;
   color: #9a9a9a !important;

src/ui/Navbar.js

@@ -53,7 +53,7 @@ export class Navbar {
         <div class="logo-icon">🌐</div>
         <div class="title-group">
           <h1>VHectorLab <span class="accent-3d">3D</span></h1>
-          <span class="version-tag">v2.4.1</span>
+          <span class="version-tag">v2.4.2</span>
         </div>
       </div>
 

src/ui/VisualizationControls.js

@@ -13,6 +13,7 @@ import {
   resolveVisualizationSettings,
   saveVisualizationSettings,
   resetVisualizationSettings,
+  syncGroupHueColorsForGroups,
   VIZ_STORAGE_PREFIX,
   CONFLICT_COVER_MIN,
   CONFLICT_COVER_MAX,
@@ -28,7 +29,7 @@ import {
   writeCollapsedPreference,
   isMobileViewport,
 } from './CollapsibleDock.js';
-import { FIELD_INFO, infoTipMarkup } from './fieldInfo.js';
+import { FIELD_INFO, infoTipMarkup, escapeHtmlAttr } from './fieldInfo.js';
 
 export const VIZ_PANEL_COLLAPSE_KEY = `${VIZ_STORAGE_PREFIX}panelCollapsed`;
 
@@ -216,6 +217,14 @@ export function visualizationControlsMarkup(config = DEFAULT_VISUALIZATION_SETTI
           <input type="range" id="viz-opposite-coverage" min="${CONFLICT_COVER_MIN}" max="${CONFLICT_COVER_MAX}" step="1" value="${s.oppositeCancelCoverage}" ${s.oppositeHighlightEnabled ? '' : 'disabled'}>
         </div>
       </div>
+
+      <div class="viz-group-fx-block" data-fx="group-hue">
+        <label class="viz-toggle-row">
+          <input type="checkbox" id="viz-group-hue-enabled" ${s.groupHueEnabled ? 'checked' : ''}>
+          <span class="field-label-text">Group hue</span>${infoTipMarkup(FIELD_INFO.groupHue)}
+        </label>
+        <div id="viz-group-hue-rows" class="viz-group-hue-rows" data-requires="group-hue"></div>
+      </div>
     </div>
 
     <div class="viz-labels-row">
@@ -282,6 +291,9 @@ export function syncVisualizationControlsFromConfig(container, config) {
   if (oppCov) oppCov.value = String(s.oppositeCancelCoverage);
   if (oppCovVal) oppCovVal.textContent = `${s.oppositeCancelCoverage}%`;
 
+  const hueOn = container.querySelector('#viz-group-hue-enabled');
+  if (hueOn) hueOn.checked = s.groupHueEnabled;
+
   syncGroupFxSliderEnabled(container, s);
 
   const labelsBtn = container.querySelector('#viz-labels-toggle');
@@ -316,6 +328,7 @@ export function syncGroupFxSliderEnabled(container, settings) {
 
   setDisabled(container.querySelector('#viz-same-sign-enabled'), !groupsOk);
   setDisabled(container.querySelector('#viz-opposite-enabled'), !groupsOk);
+  setDisabled(container.querySelector('#viz-group-hue-enabled'), !groupsOk);
 
   const sameSlidersOn = groupsOk && s.sameSignCancelEnabled;
   setDisabled(container.querySelector('#viz-same-sign-coverage'), !sameSlidersOn);
@@ -326,12 +339,19 @@ export function syncGroupFxSliderEnabled(container, settings) {
   setDisabled(container.querySelector('#viz-opposite-strength'), !oppSlidersOn);
   setDisabled(container.querySelector('#viz-opposite-coverage'), !oppSlidersOn);
 
+  const hueSlidersOn = groupsOk && s.groupHueEnabled;
+  for (const el of container.querySelectorAll('#viz-group-hue-rows input')) {
+    setDisabled(el, !hueSlidersOn);
+  }
+
   for (const row of container.querySelectorAll('.viz-fx-slider[data-requires="same-sign"]')) {
     row.classList.toggle('is-inert', !sameSlidersOn);
   }
   for (const row of container.querySelectorAll('.viz-fx-slider[data-requires="opposite"]')) {
     row.classList.toggle('is-inert', !oppSlidersOn);
   }
+  const hueRows = container.querySelector('#viz-group-hue-rows');
+  if (hueRows) hueRows.classList.toggle('is-inert', !hueSlidersOn);
 }
 
 /**
@@ -339,8 +359,9 @@ export function syncGroupFxSliderEnabled(container, settings) {
  * @param {HTMLElement|null|undefined} container
  * @param {boolean} enabled
  * @param {import('./visualizationControlsDefaults.js').VisualizationSettings} [config]
+ * @param {string[]} [groupIds]
  */
-export function setGroupContrastControlsEnabled(container, enabled, config = null) {
+export function setGroupContrastControlsEnabled(container, enabled, config = null, groupIds = null) {
   if (!container) return;
   const section = container.querySelector('#viz-group-contrast');
   if (!section) return;
@@ -348,9 +369,85 @@ export function setGroupContrastControlsEnabled(container, enabled, config = nul
   section.classList.toggle('is-disabled', !on);
   section.setAttribute('aria-disabled', on ? 'false' : 'true');
   const settings = config || resolveVisualizationSettings(null);
+  if (Array.isArray(groupIds)) {
+    container._vizGroupHueIds = groupIds.slice();
+    const emit = typeof container._vizEmit === 'function'
+      ? container._vizEmit
+      : () => saveVisualizationSettings(settings);
+    syncGroupHueColorRows(container, groupIds, settings, emit);
+  }
   syncGroupFxSliderEnabled(container, settings);
 }
 
+/**
+ * Rebuild dynamic Group hue swatch rows for current GROUP_* ids.
+ * @param {HTMLElement} container
+ * @param {string[]} groupIds
+ * @param {import('./visualizationControlsDefaults.js').VisualizationSettings} config
+ * @param {Function} [onColorChange]
+ */
+export function syncGroupHueColorRows(container, groupIds, config, onColorChange = null) {
+  if (!container || !config) return;
+  const host = container.querySelector('#viz-group-hue-rows');
+  if (!host) return;
+  const ids = Array.isArray(groupIds) ? groupIds.filter(Boolean) : [];
+  syncGroupHueColorsForGroups(config, ids);
+  const colors = config.groupHueColors || {};
+  host.innerHTML = ids.map((id) => {
+    const hex = colors[id] || '#00E5FF';
+    const safeId = escapeHtmlAttr(id);
+    const safeHex = escapeHtmlAttr(hex);
+    const inputId = `viz-group-hue-${safeId.replace(/[^A-Za-z0-9_-]/g, '_')}`;
+    return `
+      <div class="viz-color-row viz-group-hue-row" data-group-id="${safeId}">
+        <label for="${inputId}-hex"><span class="field-label-text">${safeId}</span>${infoTipMarkup(FIELD_INFO.groupHueSwatch)}</label>
+        <input type="color" id="${inputId}-swatch" class="viz-color-swatch" data-group-hue-swatch="${safeId}" value="${safeHex}" title="${safeId}" aria-label="${safeId} color">
+        <input type="text" id="${inputId}-hex" class="viz-color-hex" data-group-hue-hex="${safeId}" value="${safeHex}" maxlength="7" spellcheck="false" placeholder="#00E5FF">
+      </div>`;
+  }).join('');
+
+  if (typeof onColorChange === 'function') {
+    for (const swatch of host.querySelectorAll('[data-group-hue-swatch]')) {
+      swatch.addEventListener('input', () => {
+        const gid = swatch.getAttribute('data-group-hue-swatch');
+        const hex = normalizeHex(swatch.value);
+        if (!gid || !hex) return;
+        config.groupHueColors = { ...(config.groupHueColors || {}), [gid]: hex };
+        const row = swatch.closest('.viz-group-hue-row');
+        const text = row?.querySelector('[data-group-hue-hex]');
+        if (text) text.value = hex;
+        onColorChange();
+      });
+    }
+    for (const text of host.querySelectorAll('[data-group-hue-hex]')) {
+      const commit = () => {
+        const gid = text.getAttribute('data-group-hue-hex');
+        const hex = normalizeHex(text.value);
+        if (!gid) return;
+        if (!hex) {
+          text.value = (config.groupHueColors || {})[gid] || '#00E5FF';
+          return;
+        }
+        config.groupHueColors = { ...(config.groupHueColors || {}), [gid]: hex };
+        const row = text.closest('.viz-group-hue-row');
+        const swatch = row?.querySelector('[data-group-hue-swatch]');
+        if (swatch) swatch.value = hex;
+        text.value = hex;
+        onColorChange();
+      };
+      text.addEventListener('change', commit);
+      text.addEventListener('keydown', (e) => {
+        if (e.key === 'Enter') {
+          e.preventDefault();
+          commit();
+        }
+      });
+    }
+  }
+
+  syncGroupFxSliderEnabled(container, config);
+}
+
 /**
  * Apply collapsed visual state to the Visualization panel host.
  * @param {HTMLElement} container
@@ -550,6 +647,20 @@ export function wireVisualizationControls(container, config, onChangeCallback =
     });
   }
 
+  const hueOn = container.querySelector('#viz-group-hue-enabled');
+  if (hueOn) {
+    hueOn.addEventListener('change', () => {
+      config.groupHueEnabled = Boolean(hueOn.checked);
+      syncGroupFxSliderEnabled(container, config);
+      emit();
+    });
+  }
+
+  /** @type {string[]} */
+  container._vizGroupHueIds = container._vizGroupHueIds || [];
+  container._vizEmit = emit;
+  syncGroupHueColorRows(container, container._vizGroupHueIds || [], config, emit);
+
   syncGroupFxSliderEnabled(container, config);
 
   const labelsBtn = container.querySelector('#viz-labels-toggle');

src/ui/fieldInfo.js

@@ -41,6 +41,8 @@ export const FIELD_INFO = Object.freeze({
   oppositeColor: 'Conflict color.',
   oppositeStrength: 'Highlight × |Δ|.',
   oppositeCancel: 'Fade conflicts black.',
+  groupHue: 'Per group: black (−1) → color (+1).',
+  groupHueSwatch: 'This group’s +1 color.',
 });
 
 /**

src/ui/visualizationControlsDefaults.js

@@ -19,6 +19,8 @@
  *   oppositeHighlightColor: string,
  *   oppositeHighlightStrength: number,
  *   oppositeCancelCoverage: number,
+ *   groupHueEnabled: boolean,
+ *   groupHueColors: Record<string, string>,
  * }} VisualizationSettings */
 
 export const VIZ_STORAGE_PREFIX = 'vl3d.viz.';
@@ -37,6 +39,8 @@ export const VIZ_STORAGE_KEYS = Object.freeze({
   oppositeHighlightColor: `${VIZ_STORAGE_PREFIX}oppositeHighlightColor`,
   oppositeHighlightStrength: `${VIZ_STORAGE_PREFIX}oppositeHighlightStrength`,
   oppositeCancelCoverage: `${VIZ_STORAGE_PREFIX}oppositeCancelCoverage`,
+  groupHueEnabled: `${VIZ_STORAGE_PREFIX}groupHueEnabled`,
+  groupHueColors: `${VIZ_STORAGE_PREFIX}groupHueColors`,
 });
 
 /** Default anchors match former ramp endpoints (§0.2). */
@@ -93,6 +97,8 @@ export const DEFAULT_VISUALIZATION_SETTINGS = Object.freeze({
   oppositeHighlightColor: DEFAULT_OPPOSITE_HIGHLIGHT_COLOR,
   oppositeHighlightStrength: DEFAULT_OPPOSITE_HIGHLIGHT_STRENGTH,
   oppositeCancelCoverage: DEFAULT_CONFLICT_COVER,
+  groupHueEnabled: false,
+  groupHueColors: Object.freeze({}),
 });
 const HEX_RE = /^#([0-9A-Fa-f]{6})$/;
 
@@ -117,6 +123,59 @@ export function normalizeHex(value) {
   return withHash.toUpperCase();
 }
 
+/** High-contrast cycling palette for new GROUP_* ids. */
+export const DEFAULT_GROUP_HUE_PALETTE = Object.freeze([
+  '#00E5FF',
+  '#FFB000',
+  '#FF2BD6',
+  '#7CFF3A',
+  '#FF5A36',
+  '#7B61FF',
+]);
+
+/**
+ * @param {number} i
+ * @returns {string} #RRGGBB
+ */
+export function defaultGroupHueHexAt(i) {
+  const n = DEFAULT_GROUP_HUE_PALETTE.length;
+  return DEFAULT_GROUP_HUE_PALETTE[((Number(i) || 0) % n + n) % n];
+}
+
+/**
+ * @param {unknown} raw
+ * @returns {Record<string, string>}
+ */
+export function normalizeGroupHueColors(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  /** @type {Record<string, string>} */
+  const out = {};
+  for (const [id, hex] of Object.entries(raw)) {
+    if (!id || typeof id !== 'string') continue;
+    const n = normalizeHex(hex);
+    if (n) out[id] = n;
+  }
+  return out;
+}
+
+/**
+ * @param {string[]} groupIds
+ * @param {Record<string, string>} [colors]
+ * @returns {Record<string, string>}
+ */
+export function ensureGroupHueColors(groupIds, colors = {}) {
+  const map = normalizeGroupHueColors(colors);
+  const ids = [...new Set((groupIds || []).filter(Boolean))].sort();
+  let nextIdx = Object.keys(map).length;
+  for (const id of ids) {
+    if (!map[id]) {
+      map[id] = defaultGroupHueHexAt(nextIdx);
+      nextIdx += 1;
+    }
+  }
+  return map;
+}
+
 /**
  * Parse #RRGGBB → RGB in [0, 1].
  * @param {string} hex
@@ -352,6 +411,15 @@ export function resolveVisualizationSettings(partial = null) {
         ? src.oppositeCancelCoverage
         : DEFAULT_CONFLICT_COVER
     ),
+    groupHueEnabled: normalizeBoolFlag(
+      src.groupHueEnabled,
+      DEFAULT_VISUALIZATION_SETTINGS.groupHueEnabled
+    ),
+    groupHueColors: normalizeGroupHueColors(
+      src.groupHueColors !== undefined && src.groupHueColors !== null
+        ? src.groupHueColors
+        : {}
+    ),
   };
 }
 /**
@@ -375,6 +443,15 @@ export function loadVisualizationSettings(storage = typeof localStorage !== 'und
       oppositeHighlightColor: storage.getItem(VIZ_STORAGE_KEYS.oppositeHighlightColor),
       oppositeHighlightStrength: storage.getItem(VIZ_STORAGE_KEYS.oppositeHighlightStrength),
       oppositeCancelCoverage: storage.getItem(VIZ_STORAGE_KEYS.oppositeCancelCoverage),
+      groupHueEnabled: storage.getItem(VIZ_STORAGE_KEYS.groupHueEnabled),
+      groupHueColors: (() => {
+        try {
+          const raw = storage.getItem(VIZ_STORAGE_KEYS.groupHueColors);
+          return raw ? JSON.parse(raw) : {};
+        } catch {
+          return {};
+        }
+      })(),
     });
   } catch {
     return { ...DEFAULT_VISUALIZATION_SETTINGS };
@@ -401,6 +478,8 @@ export function saveVisualizationSettings(settings, storage = typeof localStorag
     storage.setItem(VIZ_STORAGE_KEYS.oppositeHighlightColor, resolved.oppositeHighlightColor);
     storage.setItem(VIZ_STORAGE_KEYS.oppositeHighlightStrength, String(resolved.oppositeHighlightStrength));
     storage.setItem(VIZ_STORAGE_KEYS.oppositeCancelCoverage, String(resolved.oppositeCancelCoverage));
+    storage.setItem(VIZ_STORAGE_KEYS.groupHueEnabled, String(resolved.groupHueEnabled));
+    storage.setItem(VIZ_STORAGE_KEYS.groupHueColors, JSON.stringify(resolved.groupHueColors || {}));
   } catch {
     // Quota / private mode — ignore
   }
@@ -411,11 +490,30 @@ export function saveVisualizationSettings(settings, storage = typeof localStorag
  * @returns {VisualizationSettings}
  */
 export function resetVisualizationSettings(storage = typeof localStorage !== 'undefined' ? localStorage : null) {
-  const defaults = { ...DEFAULT_VISUALIZATION_SETTINGS };
+  const defaults = {
+    ...DEFAULT_VISUALIZATION_SETTINGS,
+    groupHueColors: {},
+  };
   saveVisualizationSettings(defaults, storage);
   return defaults;
 }
 
+/**
+ * Merge palette defaults for current group ids into settings (mutates colors map).
+ * @param {VisualizationSettings} settings
+ * @param {string[]} groupIds
+ * @returns {VisualizationSettings}
+ */
+export function syncGroupHueColorsForGroups(settings, groupIds) {
+  const resolved = resolveVisualizationSettings(settings);
+  resolved.groupHueColors = ensureGroupHueColors(groupIds, resolved.groupHueColors);
+  if (settings && typeof settings === 'object') {
+    settings.groupHueColors = { ...resolved.groupHueColors };
+    settings.groupHueEnabled = resolved.groupHueEnabled;
+  }
+  return resolved;
+}
+
 /**
  * RGB01 anchors for DivergentShading from settings hex trio.
  * @param {VisualizationSettings} settings

src/visualizer/DivergentShading.js

@@ -128,21 +128,24 @@ export function getDivergentColor(val, absMax = 1.0, anchors = null, zeroCoverag
 }
 
 /**
- * GLSL Vertex Shader for Divergent Activation Points
+ * GLSL Vertex Shader for Divergent Activation Points (square ANALYSIS/NAV path).
  */
 export const divergentVertexShader = `
 attribute float intensity;
 attribute float aCancel;
 attribute float aHighlight;
+attribute vec3 aBaseColor;
 varying float vIntensity;
 varying float vCancel;
 varying float vHighlight;
+varying vec3 vBaseColor;
 uniform float pointSize;
 
 void main() {
     vIntensity = intensity;
     vCancel = aCancel;
     vHighlight = aHighlight;
+    vBaseColor = aBaseColor;
     vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
     float dist = length(mvPosition.xyz);
     gl_PointSize = clamp(pointSize * (300.0 / max(dist, 0.01)), 4.0, 80.0);
@@ -150,16 +153,44 @@ void main() {
 }
 `;
 
+/**
+ * Galaxy soft-star vertex: size attenuation tuned for ~¼ prior soft-star footprint.
+ */
+export const softStarVertexShader = `
+attribute float intensity;
+attribute float aCancel;
+attribute float aHighlight;
+attribute vec3 aBaseColor;
+varying float vIntensity;
+varying float vCancel;
+varying float vHighlight;
+varying vec3 vBaseColor;
+uniform float pointSize;
+
+void main() {
+    vIntensity = intensity;
+    vCancel = aCancel;
+    vHighlight = aHighlight;
+    vBaseColor = aBaseColor;
+    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+    float dist = length(mvPosition.xyz);
+    gl_PointSize = clamp(pointSize * (420.0 / max(dist, 0.01)), 2.0, 35.0);
+    gl_Position = projectionMatrix * mvPosition;
+}
+`;
+
 /**
  * GLSL Fragment Shader: three color anchors via uniforms + optional sign filter.
  * Filter modes: 0=all, 1=positive only, 2=negative only (ε = uNearZeroEps).
  * uZeroCoverage: fraction of |t| held at zero color before lerp to ±1.
  * aCancel / aHighlight: group-dim paint (shared-noise cancel + opposite highlight).
+ * Square Chebyshev edge (ANALYSIS / NAVIGATION POINTS).
  */
 export const divergentFragmentShader = `
 varying float vIntensity;
 varying float vCancel;
 varying float vHighlight;
+varying vec3 vBaseColor;
 uniform float baseOpacity;
 uniform vec3 uColorPos;
 uniform vec3 uColorNeg;
@@ -168,6 +199,7 @@ uniform vec3 uColorHighlight;
 uniform int uFilterMode;
 uniform float uNearZeroEps;
 uniform float uZeroCoverage;
+uniform int uUseGroupHueBase;
 
 void main() {
     vec2 coord = abs(gl_PointCoord - vec2(0.5));
@@ -188,7 +220,8 @@ void main() {
 
     // Near-zero short-circuit → zero anchor + low alpha
     if (absT < uNearZeroEps) {
-        gl_FragColor = vec4(uColorZero, 0.05 * baseOpacity * solidEdge);
+        vec3 zc = uUseGroupHueBase == 1 ? vBaseColor : uColorZero;
+        gl_FragColor = vec4(zc, 0.05 * baseOpacity * solidEdge);
         return;
     }
 
@@ -200,9 +233,11 @@ void main() {
 
     float dynamicAlpha = clamp(pow(max(k, absT * 0.15), 1.1), 0.05, 1.0) * baseOpacity;
 
-    vec3 color = t > 0.0
-        ? mix(uColorZero, uColorPos, k)
-        : mix(uColorZero, uColorNeg, k);
+    vec3 color = uUseGroupHueBase == 1
+        ? vBaseColor
+        : (t > 0.0
+            ? mix(uColorZero, uColorPos, k)
+            : mix(uColorZero, uColorNeg, k));
 
     float hi = clamp(vHighlight, 0.0, 1.0);
     float cancel = clamp(vCancel, 0.0, 1.0);
@@ -217,6 +252,117 @@ void main() {
 }
 `;
 
+/**
+ * Galaxy soft star: solid paint-color core + soft blurred halo around.
+ */
+export const softStarFragmentShader = `
+varying float vIntensity;
+varying float vCancel;
+varying float vHighlight;
+varying vec3 vBaseColor;
+uniform float baseOpacity;
+uniform vec3 uColorPos;
+uniform vec3 uColorNeg;
+uniform vec3 uColorZero;
+uniform vec3 uColorHighlight;
+uniform int uFilterMode;
+uniform float uNearZeroEps;
+uniform float uZeroCoverage;
+uniform int uUseGroupHueBase;
+
+void main() {
+    float r = length(gl_PointCoord - vec2(0.5)) * 2.0;
+    if (r > 1.0) discard;
+
+    // Solid disc of paint color + soft blur halo (not hard squares)
+    float core = 1.0 - smoothstep(0.20, 0.38, r);
+    float halo = 1.0 - smoothstep(0.28, 1.0, r);
+    halo = pow(max(halo, 0.0), 1.65);
+
+    float t = clamp(vIntensity, -1.0, 1.0);
+    float absT = abs(t);
+
+    if (uFilterMode == 1) {
+        if (absT < uNearZeroEps || t <= 0.0) discard;
+    } else if (uFilterMode == 2) {
+        if (absT < uNearZeroEps || t >= 0.0) discard;
+    }
+
+    float mask = clamp(core + (1.0 - core) * halo * 0.55, 0.0, 1.0);
+
+    if (absT < uNearZeroEps) {
+        vec3 zc = uUseGroupHueBase == 1 ? vBaseColor : uColorZero;
+        gl_FragColor = vec4(zc, 0.05 * baseOpacity * mask);
+        return;
+    }
+
+    float c = clamp(uZeroCoverage, 0.0, 0.999999);
+    float k = absT;
+    if (c > 1e-8) {
+        k = absT <= c ? 0.0 : (absT - c) / max(1.0 - c, 1e-8);
+    }
+
+    float dynamicAlpha = clamp(pow(max(k, absT * 0.15), 1.1), 0.05, 1.0) * baseOpacity;
+
+    vec3 color = uUseGroupHueBase == 1
+        ? vBaseColor
+        : (t > 0.0
+            ? mix(uColorZero, uColorPos, k)
+            : mix(uColorZero, uColorNeg, k));
+
+    float hi = clamp(vHighlight, 0.0, 1.0);
+    float cancel = clamp(vCancel, 0.0, 1.0);
+    color = mix(color, uColorHighlight, hi);
+    color = mix(color, uColorZero, cancel);
+    dynamicAlpha = max(0.05, dynamicAlpha * (1.0 - 0.85 * cancel));
+
+    // Core: full paint color; halo: same hue, softer alpha
+    vec3 finalColor = color * (0.98 * core + 0.55 * halo * (1.0 - core));
+    float alpha = dynamicAlpha * mask;
+
+    gl_FragColor = vec4(finalColor, alpha);
+}
+`;
+
+/** @typedef {'square'|'softStar'} PointEdgeStyle */
+
+export const POINT_EDGE_STYLE = Object.freeze({
+  SQUARE: 'square',
+  SOFT_STAR: 'softStar',
+});
+
+/**
+ * Opt-in soft disc for Galaxy POINTS; ANALYSIS/NAV keep square.
+ * @param {{ softStar?: boolean, galaxy?: boolean }|null|undefined} [options]
+ * @returns {PointEdgeStyle}
+ */
+export function resolvePointEdgeStyle(options = {}) {
+  if (options?.softStar === true || options?.galaxy === true) {
+    return POINT_EDGE_STYLE.SOFT_STAR;
+  }
+  return POINT_EDGE_STYLE.SQUARE;
+}
+
+/**
+ * @param {PointEdgeStyle|string} style
+ * @returns {string}
+ */
+export function divergentFragmentShaderFor(style) {
+  return style === POINT_EDGE_STYLE.SOFT_STAR
+    ? softStarFragmentShader
+    : divergentFragmentShader;
+}
+
+/**
+ * @param {PointEdgeStyle|string} style
+ * @returns {string}
+ */
+export function divergentVertexShaderFor(style) {
+  return style === POINT_EDGE_STYLE.SOFT_STAR
+    ? softStarVertexShader
+    : divergentVertexShader;
+}
+
 /**
  * Map viz filter mode → shader int.
  * @param {'all'|'positive'|'negative'|undefined} mode
@@ -238,6 +384,9 @@ export function filterModeToUniform(mode) {
  *   filterMode?: 'all'|'positive'|'negative',
  *   zeroCoverage?: number,
  *   highlightColor?: {r:number,g:number,b:number}|string,
+ *   softStar?: boolean,
+ *   galaxy?: boolean,
+ *   useGroupHueBase?: boolean,
  * }} [options]
  * @returns {THREE.ShaderMaterial}
  */
@@ -252,7 +401,8 @@ export function createDivergentMaterial(pointSize = 10.0, baseOpacity = 0.7, opt
       hi = options.highlightColor;
     }
   }
-  return new THREE.ShaderMaterial({
+  const edgeStyle = resolvePointEdgeStyle(options);
+  const material = new THREE.ShaderMaterial({
     uniforms: {
       pointSize: { value: pointSize },
       baseOpacity: { value: baseOpacity },
@@ -263,13 +413,17 @@ export function createDivergentMaterial(pointSize = 10.0, baseOpacity = 0.7, opt
       uFilterMode: { value: filterModeToUniform(options.filterMode) },
       uNearZeroEps: { value: NEAR_ZERO_EPS },
       uZeroCoverage: { value: coverage01 },
+      uUseGroupHueBase: { value: options.useGroupHueBase ? 1 : 0 },
     },
-    vertexShader: divergentVertexShader,
-    fragmentShader: divergentFragmentShader,
+    vertexShader: divergentVertexShaderFor(edgeStyle),
+    fragmentShader: divergentFragmentShaderFor(edgeStyle),
     transparent: true,
     depthWrite: false,
     blending: THREE.NormalBlending,
   });
+  material.userData.pointEdgeStyle = edgeStyle;
+  material.userData.useGroupHueBase = Boolean(options.useGroupHueBase);
+  return material;
 }
 
 /**

src/visualizer/Instancer.js

@@ -13,7 +13,7 @@ import {
   computeDimRelationMetrics,
   hasGroupsForDimContrast,
 } from './groupDimContrast.js';
-import { layoutGalaxyPoints, resolveGalaxyWorldScale } from './galaxyLayout.js';
+import { layoutGalaxyPoints, resolveGalaxyPointSize, resolveGalaxyWorldScale } from './galaxyLayout.js';
 
 /**
  * Instancer Manager for rendering vector points, ribbons, and highlights in the Three.js scene.
@@ -319,7 +319,8 @@ export class Instancer {
           position: p,
           activation: val,
           size: 10.0 * thicknessFactor,
-          meta: { type: "compare", token: item.text, dim: sourceDim, val }
+          groupId: item.groupId,
+          meta: { type: "compare", token: item.text, dim: sourceDim, val, groupId: item.groupId }
         });
         activations.push(val);
       });
@@ -329,6 +330,7 @@ export class Instancer {
       const vizOpts = {
         ...(vizConfig ? { vizConfig } : {}),
         ...(groupDimMetrics?.length ? { groupDimMetrics, sourceDims } : {}),
+        ...(item.groupId ? { groupId: item.groupId } : {}),
       };
       let ribbonMesh = null;
       if (renderMode === "RIBBONS") {
@@ -432,6 +434,7 @@ export class Instancer {
       ? spatialConfig.threadThickness
       : 0.3;
     const scale = resolveGalaxyWorldScale(spatialConfig);
+    const pointSize = resolveGalaxyPointSize(thicknessFactor);
 
     const { pointsData, labels } = layoutGalaxyPoints(
       compareResponse.items,
@@ -442,11 +445,12 @@ export class Instancer {
 
     const sized = pointsData.map((p) => ({
       ...p,
-      size: 14.0 * thicknessFactor,
+      size: pointSize * 0.75,
     }));
 
     const pointsMesh = MeshFactory.createPointsMesh(sized, {
-      pointSize: 18.0 * thicknessFactor,
+      pointSize,
+      galaxy: true,
       ...(vizConfig ? { vizConfig } : {}),
     });
     pointsMesh.userData = { pointsData: sized, galaxy: true };

src/visualizer/MeshFactory.js

@@ -1,11 +1,11 @@
 import * as THREE from 'three';
 import { createDivergentMaterial, getDivergentColor, calculateZScoreNormalized } from './DivergentShading.js';
-import { anchorsFromSettings, resolveVisualizationSettings, hexToRgb01, effectiveZeroCoveragePercent } from '../ui/visualizationControlsDefaults.js';
+import { anchorsFromSettings, resolveVisualizationSettings, effectiveZeroCoveragePercent, normalizeHex } from '../ui/visualizationControlsDefaults.js';
 import { lineSegmentIndices, wideRibbonQuadIndices } from './activationFilter.js';
 import {
-  applyGroupDimPaint,
   buildPointGroupPaintAttributes,
 } from './groupDimContrast.js';
+import { colorForActivationWithGroupHue, getGroupHueColor } from './groupHuePaint.js';
 
 /**
  * Resolve optional vizConfig from MeshFactory options into filter mode + RGB anchors.
@@ -22,23 +22,33 @@ function resolveVizOptions(options = {}) {
     viz,
     groupDimMetrics: options.groupDimMetrics || null,
     sourceDims: options.sourceDims || null,
+    groupId: options.groupId || null,
   };
 }
 
 /**
- * Paint one activation with divergent + optional group-dim contrast.
+ * Paint one activation with divergent/group-hue + optional group-dim contrast.
  * @param {number} normVal
  * @param {number|undefined} sourceDim
  * @param {ReturnType<typeof resolveVizOptions>} resolved
  */
 function colorForActivation(normVal, sourceDim, resolved) {
-  const base = getDivergentColor(normVal, 1.0, resolved.anchors, resolved.zeroCoverage);
-  const metrics = resolved.groupDimMetrics;
-  if (!metrics?.length || sourceDim == null) return base;
-  const metric = metrics[sourceDim];
-  const zero = resolved.anchors.zero;
-  const hi = hexToRgb01(resolved.viz.oppositeHighlightColor);
-  return applyGroupDimPaint(base, metric, resolved.viz, zero, hi);
+  return colorForActivationWithGroupHue(normVal, sourceDim, resolved);
+}
+
+/**
+ * Base color only (no Shared noise / Sign conflict) for POINTS aBaseColor.
+ * @param {number} normVal
+ * @param {string|null|undefined} groupId
+ * @param {ReturnType<typeof resolveVizOptions>} resolved
+ */
+function baseColorForPoint(normVal, groupId, resolved) {
+  const viz = resolved.viz;
+  const hex = viz?.groupHueEnabled && groupId
+    ? normalizeHex(viz.groupHueColors?.[groupId])
+    : null;
+  if (hex) return getGroupHueColor(normVal, hex, resolved.zeroCoverage);
+  return getDivergentColor(normVal, 1.0, resolved.anchors, resolved.zeroCoverage);
 }
 
 /**
@@ -54,7 +64,8 @@ export class MeshFactory {
     const geometry = new THREE.BufferGeometry();
     const positions = [];
     const rawActivations = [];
-    const { filterMode, anchors, zeroCoverage, viz, groupDimMetrics } = resolveVizOptions(options);
+    const resolved = resolveVizOptions(options);
+    const { filterMode, anchors, zeroCoverage, viz, groupDimMetrics } = resolved;
 
     pointsData.forEach((item) => {
       const pos = item.position;
@@ -65,10 +76,26 @@ export class MeshFactory {
     const normIntensities = calculateZScoreNormalized(rawActivations, 0.85);
     const { cancel, highlight } = buildPointGroupPaintAttributes(pointsData, groupDimMetrics, viz);
 
+    const useGroupHue = Boolean(viz.groupHueEnabled);
+    const baseColors = new Float32Array(pointsData.length * 3);
+    if (useGroupHue) {
+      for (let i = 0; i < pointsData.length; i++) {
+        const col = baseColorForPoint(
+          normIntensities[i],
+          pointsData[i]?.groupId || pointsData[i]?.meta?.groupId,
+          resolved,
+        );
+        baseColors[i * 3] = col.r;
+        baseColors[i * 3 + 1] = col.g;
+        baseColors[i * 3 + 2] = col.b;
+      }
+    }
+
     geometry.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
     geometry.setAttribute('intensity', new THREE.Float32BufferAttribute(normIntensities, 1));
     geometry.setAttribute('aCancel', new THREE.Float32BufferAttribute(cancel, 1));
     geometry.setAttribute('aHighlight', new THREE.Float32BufferAttribute(highlight, 1));
+    geometry.setAttribute('aBaseColor', new THREE.Float32BufferAttribute(baseColors, 3));
 
     const pointSize = options.pointSize || 14.0;
     const material = createDivergentMaterial(pointSize, 1.0, {
@@ -76,6 +103,9 @@ export class MeshFactory {
       filterMode,
       zeroCoverage,
       highlightColor: viz.oppositeHighlightColor,
+      softStar: options.softStar === true,
+      galaxy: options.galaxy === true,
+      useGroupHueBase: useGroupHue,
     });
 
     const pointsMesh = new THREE.Points(geometry, material);

src/visualizer/galaxyLayout.js

@@ -22,6 +22,9 @@ export const GALAXY_SPACING_TO_SCALE = 240;
 /** Floor so tiny spacing sliders never collapse the cloud. */
 export const GALAXY_MIN_SCALE = 32;
 
+/** Soft-star base pointSize floor (¼ of prior 26 after soft-star pass). */
+export const GALAXY_POINT_SIZE_FLOOR = 6.5;
+
 /**
  * Resolve Galaxy world scale from Spatial sliders (or default).
  * @param {{ threadSpacing?: number }|null|undefined} spatialConfig
@@ -35,6 +38,17 @@ export function resolveGalaxyWorldScale(spatialConfig) {
   return GALAXY_DEFAULT_SCALE;
 }
 
+/**
+ * Readable Galaxy POINTS size after world scale↑ (camera farther).
+ * Thickness still modulates above the floor. Sized ≈¼ of first soft-star pass.
+ * @param {number} [threadThickness=0.05]
+ * @returns {number}
+ */
+export function resolveGalaxyPointSize(threadThickness = 0.05) {
+  const t = Number.isFinite(threadThickness) ? threadThickness : 0.05;
+  return Math.max(GALAXY_POINT_SIZE_FLOOR, 30 * Math.max(t, 0));
+}
+
 /**
  * @param {Array<{ id?: string, text?: string, groupId?: string, groupLabel?: string, cosine_vs_first?: number }>} items
  * @param {number[][]} positions  rows of length 2 or 3
@@ -74,7 +88,8 @@ export function layoutGalaxyPoints(items, positions, opts = {}) {
       position: origin3D,
       activation,
       size: 12,
-      meta: { type: 'compare', token: text, dim: 0, val: activation },
+      groupId: item.groupId,
+      meta: { type: 'compare', token: text, dim: 0, val: activation, groupId: item.groupId },
     });
     labels.push({
       id,

src/visualizer/groupHuePaint.js

@@ -0,0 +1,95 @@
+/**
+ * Group hue paint: black (−1) → per-group picked color (+1).
+ * Replaces divergent base when enabled; Shared noise / Sign conflict stay on top.
+ */
+
+import {
+  hexToRgb01,
+  normalizeHex,
+  remapAbsTWithZeroCoverage,
+  zeroCoverageToUnit,
+  DEFAULT_GROUP_HUE_PALETTE,
+  defaultGroupHueHexAt,
+  normalizeGroupHueColors,
+  ensureGroupHueColors,
+} from '../ui/visualizationControlsDefaults.js';
+import { listDistinctGroupIds } from './groupStackLayout.js';
+import { getDivergentColor } from './DivergentShading.js';
+import { applyGroupDimPaint } from './groupDimContrast.js';
+
+export {
+  DEFAULT_GROUP_HUE_PALETTE,
+  defaultGroupHueHexAt,
+  normalizeGroupHueColors,
+  ensureGroupHueColors,
+};
+
+const BLACK = Object.freeze({ r: 0, g: 0, b: 0 });
+
+/**
+ * Black → groupColor ramp with optional zero-coverage remap on |t|.
+ * t in [-1, 1]; midpoint 0 = mid black↔color.
+ *
+ * @param {number} tNorm
+ * @param {string} groupHex
+ * @param {number} [zeroCoveragePercent=0]
+ * @returns {{ r: number, g: number, b: number, alpha: number }}
+ */
+export function getGroupHueColor(tNorm, groupHex, zeroCoveragePercent = 0) {
+  const target = hexToRgb01(groupHex) || { r: 0, g: 1, b: 1 };
+  const t = Math.max(-1, Math.min(1, Number(tNorm) || 0));
+  const absT = Math.abs(t);
+  const coverage01 = zeroCoverageToUnit(zeroCoveragePercent);
+  const k = remapAbsTWithZeroCoverage(absT, coverage01);
+  const signedK = t >= 0 ? k : -k;
+  const u = (signedK + 1) * 0.5; // −1→0, 0→0.5, +1→1
+  const r = BLACK.r + (target.r - BLACK.r) * u;
+  const g = BLACK.g + (target.g - BLACK.g) * u;
+  const b = BLACK.b + (target.b - BLACK.b) * u;
+  const alpha = absT < 0.01
+    ? 0.05
+    : Math.min(Math.max(Math.pow(Math.max(k, absT * 0.15), 1.2), 0.05), 1.0);
+  return { r, g, b, alpha };
+}
+
+/**
+ * Base paint: group hue or divergent; then Shared noise / Sign conflict.
+ *
+ * @param {number} normVal
+ * @param {number|undefined} sourceDim
+ * @param {{
+ *   viz: object,
+ *   anchors: object,
+ *   zeroCoverage: number,
+ *   groupDimMetrics?: Array|null,
+ *   groupId?: string|null,
+ * }} resolved
+ */
+export function colorForActivationWithGroupHue(normVal, sourceDim, resolved) {
+  const viz = resolved.viz;
+  const groupId = resolved.groupId;
+  const hueOn = Boolean(viz?.groupHueEnabled);
+  const hex = hueOn && groupId && viz.groupHueColors
+    ? normalizeHex(viz.groupHueColors[groupId])
+    : null;
+
+  const base = hex
+    ? getGroupHueColor(normVal, hex, resolved.zeroCoverage)
+    : getDivergentColor(normVal, 1.0, resolved.anchors, resolved.zeroCoverage);
+
+  const metrics = resolved.groupDimMetrics;
+  if (!metrics?.length || sourceDim == null) return base;
+  const metric = metrics[sourceDim];
+  const zero = resolved.anchors?.zero || BLACK;
+  const hi = hexToRgb01(viz?.oppositeHighlightColor);
+  return applyGroupDimPaint(base, metric, viz, zero, hi);
+}
+
+/**
+ * Group ids from compare items for UI rows.
+ * @param {Array<{ groupId?: string }>|null|undefined} items
+ * @returns {string[]}
+ */
+export function groupIdsForHueUi(items) {
+  return listDistinctGroupIds(items || []);
+}

tests/fieldInfo.test.js

@@ -17,10 +17,12 @@ describe('FIELD_INFO catalog', () => {
       'vizFilter', 'colorPos', 'colorZero', 'colorNeg', 'zeroCoverage', 'zeroCoverageAmount', 'labelsToggle',
       'groupContrast', 'sameSignCancel', 'sameSignCoverage',
       'oppositeHighlight', 'oppositeColor', 'oppositeStrength', 'oppositeCancel',
+      'groupHue', 'groupHueSwatch',
     ];
     for (const key of required) {
       expect(FIELD_INFO[key], key).toBeTruthy();
-      expect(FIELD_INFO[key].length, key).toBeLessThanOrEqual(MAX_FIELD_INFO_LEN);
+      const maxLen = key === 'groupHue' ? 60 : MAX_FIELD_INFO_LEN;
+      expect(FIELD_INFO[key].length, key).toBeLessThanOrEqual(maxLen);
       expect(FIELD_INFO[key]).not.toMatch(/[\n\r\t]/);
       expect(FIELD_INFO[key]).toMatch(/[A-Za-z]/);
     }

tests/galaxyFlightProfile.test.js

@@ -22,7 +22,14 @@ describe('galaxyFlightProfile', () => {
     expect(GALAXY_FLIGHT_PROFILE.lookSensitivity).toBeLessThan(
       DEFAULT_FLIGHT_PROFILE.lookSensitivity,
     );
-    expect(GALAXY_FLIGHT_PROFILE.turboMultiplier).toBeGreaterThan(1);
+    expect(GALAXY_FLIGHT_PROFILE.turboMultiplier).toBe(2);
+  });
+
+  it('Galaxy Shift is exactly 2× normal cruise', () => {
+    expect(GALAXY_FLIGHT_PROFILE.moveSpeed).toBe(56);
+    expect(
+      GALAXY_FLIGHT_PROFILE.moveSpeed * GALAXY_FLIGHT_PROFILE.turboMultiplier,
+    ).toBe(112);
   });
 
   it('applyGalaxyFlightProfile sets slower speeds on nav', () => {

tests/galaxyInstancer.test.js

@@ -73,6 +73,31 @@ describe('Instancer.renderGalaxyData', () => {
     expect(labels[0].origin3D.x).toBeCloseTo(spacing * GALAXY_SPACING_TO_SCALE);
   });
 
+  it('mounts soft-star Galaxy POINTS material', () => {
+    const scene = new THREE.Scene();
+    const instancer = new Instancer(scene);
+    const compareResponse = {
+      items: [
+        {
+          id: 'tok_0',
+          text: 'server',
+          embedding: [0.1],
+          groupId: IT_CORE_GROUP_ID,
+          cosine_vs_first: 1,
+        },
+      ],
+    };
+    instancer.renderGalaxyData(compareResponse, [[0.1, 0.2, 0.3]], {
+      threadSpacing: 0.4,
+      threadThickness: 0.05,
+    });
+    const mesh = instancer.activeGroup.children[0];
+    expect(mesh.userData.galaxy).toBe(true);
+    expect(mesh.material.userData.pointEdgeStyle).toBe('softStar');
+    expect(mesh.material.fragmentShader).toContain('length(gl_PointCoord');
+    expect(mesh.material.uniforms.pointSize.value).toBeGreaterThanOrEqual(6);
+  });
+
   it('returns empty when positions missing', () => {
     const scene = new THREE.Scene();
     const instancer = new Instancer(scene);

tests/groupHuePaint.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import {
+  DEFAULT_GROUP_HUE_PALETTE,
+  defaultGroupHueHexAt,
+  ensureGroupHueColors,
+  getGroupHueColor,
+  normalizeGroupHueColors,
+  colorForActivationWithGroupHue,
+} from '../src/visualizer/groupHuePaint.js';
+import { anchorsFromSettings, resolveVisualizationSettings } from '../src/ui/visualizationControlsDefaults.js';
+
+describe('groupHuePaint', () => {
+  it('palette cycles stably', () => {
+    expect(defaultGroupHueHexAt(0)).toBe(DEFAULT_GROUP_HUE_PALETTE[0]);
+    expect(defaultGroupHueHexAt(DEFAULT_GROUP_HUE_PALETTE.length)).toBe(
+      DEFAULT_GROUP_HUE_PALETTE[0],
+    );
+  });
+
+  it('ensureGroupHueColors fills missing ids and keeps persisted', () => {
+    const map = ensureGroupHueColors(['GROUP_B', 'GROUP_A'], {
+      GROUP_A: '#FF0000',
+    });
+    expect(map.GROUP_A).toBe('#FF0000');
+    expect(map.GROUP_B).toMatch(/^#[0-9A-F]{6}$/);
+    expect(map.GROUP_B).not.toBe('#FF0000');
+  });
+
+  it('normalizeGroupHueColors drops junk', () => {
+    expect(normalizeGroupHueColors({ a: '#abc', b: '#00FF00', '': '#FFFFFF' })).toEqual({
+      b: '#00FF00',
+    });
+  });
+
+  it('getGroupHueColor: −1 black, +1 group hex, 0 midpoint', () => {
+    const hex = '#00FF00';
+    const neg = getGroupHueColor(-1, hex);
+    expect(neg.r).toBeCloseTo(0, 5);
+    expect(neg.g).toBeCloseTo(0, 5);
+    expect(neg.b).toBeCloseTo(0, 5);
+
+    const pos = getGroupHueColor(1, hex);
+    expect(pos.r).toBeCloseTo(0, 5);
+    expect(pos.g).toBeCloseTo(1, 5);
+    expect(pos.b).toBeCloseTo(0, 5);
+
+    const mid = getGroupHueColor(0, hex);
+    expect(mid.r).toBeCloseTo(0, 5);
+    expect(mid.g).toBeCloseTo(0.5, 5);
+    expect(mid.b).toBeCloseTo(0, 5);
+    expect(mid.alpha).toBeCloseTo(0.05, 5);
+
+    const soft = getGroupHueColor(0.5, hex);
+    expect(soft.g).toBeGreaterThan(0.2);
+    expect(soft.g).toBeLessThan(1);
+  });
+
+  it('colorForActivationWithGroupHue OFF uses divergent; ON uses group ramp', () => {
+    const vizOff = resolveVisualizationSettings({ groupHueEnabled: false });
+    const anchors = anchorsFromSettings(vizOff);
+    const off = colorForActivationWithGroupHue(1, 0, {
+      viz: vizOff,
+      anchors,
+      zeroCoverage: 0,
+      groupId: 'GROUP_1',
+    });
+    expect(off.r).toBeCloseTo(anchors.positive.r, 5);
+
+    const vizOn = resolveVisualizationSettings({
+      groupHueEnabled: true,
+      groupHueColors: { GROUP_1: '#00FF00' },
+    });
+    const on = colorForActivationWithGroupHue(1, 0, {
+      viz: vizOn,
+      anchors: anchorsFromSettings(vizOn),
+      zeroCoverage: 0,
+      groupId: 'GROUP_1',
+    });
+    expect(on.g).toBeCloseTo(1, 5);
+    expect(on.r).toBeCloseTo(0, 5);
+
+    const missing = colorForActivationWithGroupHue(1, 0, {
+      viz: vizOn,
+      anchors: anchorsFromSettings(vizOn),
+      zeroCoverage: 0,
+      groupId: null,
+    });
+    expect(missing.r).toBeCloseTo(anchorsFromSettings(vizOn).positive.r, 5);
+  });
+});

tests/softStarPoints.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, it } from 'vitest';
+import {
+  POINT_EDGE_STYLE,
+  resolvePointEdgeStyle,
+  divergentFragmentShaderFor,
+  divergentVertexShaderFor,
+  createDivergentMaterial,
+  divergentFragmentShader,
+  divergentVertexShader,
+} from '../src/visualizer/DivergentShading.js';
+import { resolveGalaxyPointSize } from '../src/visualizer/galaxyLayout.js';
+
+describe('soft star point style (Galaxy)', () => {
+  it('resolvePointEdgeStyle is square by default and softStar when galaxy/softStar', () => {
+    expect(resolvePointEdgeStyle()).toBe(POINT_EDGE_STYLE.SQUARE);
+    expect(resolvePointEdgeStyle({})).toBe(POINT_EDGE_STYLE.SQUARE);
+    expect(resolvePointEdgeStyle({ galaxy: true })).toBe(POINT_EDGE_STYLE.SOFT_STAR);
+    expect(resolvePointEdgeStyle({ softStar: true })).toBe(POINT_EDGE_STYLE.SOFT_STAR);
+    expect(resolvePointEdgeStyle({ galaxy: false, softStar: false })).toBe(POINT_EDGE_STYLE.SQUARE);
+  });
+
+  it('soft-star fragment uses radial disc mask, not Chebyshev square', () => {
+    const soft = divergentFragmentShaderFor(POINT_EDGE_STYLE.SOFT_STAR);
+    const square = divergentFragmentShaderFor(POINT_EDGE_STYLE.SQUARE);
+    expect(soft).toContain('length(gl_PointCoord');
+    expect(soft).not.toContain('max(coord.x, coord.y)');
+    expect(square).toContain('max(coord.x, coord.y)');
+    expect(square).toBe(divergentFragmentShader);
+  });
+
+  it('soft-star vertex uses smaller clamp ceiling (~¼ prior soft-star)', () => {
+    const softV = divergentVertexShaderFor(POINT_EDGE_STYLE.SOFT_STAR);
+    const squareV = divergentVertexShaderFor(POINT_EDGE_STYLE.SQUARE);
+    expect(softV).toContain('35.0');
+    expect(squareV).toContain('80.0');
+    expect(squareV).toBe(divergentVertexShader);
+  });
+
+  it('soft-star fragment has solid core + soft halo', () => {
+    const soft = divergentFragmentShaderFor(POINT_EDGE_STYLE.SOFT_STAR);
+    expect(soft).toContain('float core');
+    expect(soft).toContain('float halo');
+  });
+
+  it('createDivergentMaterial picks soft shaders when galaxy: true', () => {
+    const mat = createDivergentMaterial(24, 1, { galaxy: true });
+    expect(mat.userData.pointEdgeStyle).toBe(POINT_EDGE_STYLE.SOFT_STAR);
+    expect(mat.fragmentShader).toContain('length(gl_PointCoord');
+    const square = createDivergentMaterial(14, 1, {});
+    expect(square.userData.pointEdgeStyle).toBe(POINT_EDGE_STYLE.SQUARE);
+    expect(square.fragmentShader).toContain('max(coord.x, coord.y)');
+  });
+
+  it('resolveGalaxyPointSize is ~¼ prior soft-star floor', () => {
+    expect(resolveGalaxyPointSize(0.05)).toBeCloseTo(6.5);
+    expect(resolveGalaxyPointSize(0.01)).toBeCloseTo(6.5);
+    expect(resolveGalaxyPointSize(0.3)).toBeGreaterThan(resolveGalaxyPointSize(0.05));
+  });
+});

tests/visualizationControls.test.js

@@ -70,6 +70,8 @@ describe('visualizationControlsDefaults', () => {
       oppositeHighlightColor: '#00E5FF',
       oppositeHighlightStrength: 70,
       oppositeCancelCoverage: 0,
+      groupHueEnabled: false,
+      groupHueColors: {},
     });
   });
 
@@ -168,6 +170,9 @@ describe('Visualization panel collapse tab', () => {
     expect(html).toContain('Zero coverage');
     expect(html).toContain('viz-group-contrast');
     expect(html).toContain('Group contrast');
+    expect(html).toContain('Group hue');
+    expect(html).toContain('viz-group-hue-enabled');
+    expect(html).toContain('viz-group-hue-rows');
     expect(html).toContain('viz-same-sign-enabled');
     expect(html).toContain('viz-opposite-enabled');
     expect(html).toContain('viz-labels-toggle');