feat(selection): show stock industry and concept boards in detail panel

Add point-in-time stock membership lookup to the sector radar module
(GET /sector-radar/stocks/{ts_code}/membership) reading the existing
dc_index/dc_member snapshots, and surface industries plus concept chips
in the selection signal detail panel with graceful no-data hiding.

zhixing-server/src/zhixing_server/modules/sector_radar/application/read.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+from collections.abc import Iterator
 from dataclasses import dataclass
 from datetime import date
 from enum import StrEnum
@@ -20,11 +21,13 @@ from ..domain.models import (
     RankSide,
     SectorType,
 )
-from ..domain.persistence import SectorRadarRepository
+from ..domain.persistence import SectorRadarRepository, StockMembershipEntry
 from ..domain.ranking import select_percentile_side, select_rank_change_side
 
 ReadStatus = Literal["success", "no_data"]
 
+STOCK_SECTOR_CONCEPT_LIMIT = 20
+
 
 class RadarView(StrEnum):
     """Supported ranking projections at the HTTP boundary."""
@@ -101,6 +104,50 @@ class RankingPage:
     total: int
 
 
+@dataclass(frozen=True, slots=True)
+class SectorRef:
+    """Public identity of one sector that claimed a stock."""
+
+    code: str
+    name: str
+
+
+@dataclass(frozen=True, slots=True)
+class StockSectorQuery:
+    """Validated application query for one stock's point-in-time membership."""
+
+    trade_date: date
+    ts_code: str
+    concept_limit: int = STOCK_SECTOR_CONCEPT_LIMIT
+
+    def __post_init__(self) -> None:
+        """Reject empty stock codes and non-positive concept limits."""
+
+        if not self.ts_code.strip():
+            raise ValueError("ts_code must not be empty")
+        if len(self.ts_code) > 12:
+            raise ValueError("ts_code must not exceed 12 characters")
+        if self.concept_limit < 1:
+            raise ValueError("concept_limit must be at least 1")
+
+
+@dataclass(frozen=True, slots=True)
+class StockSectorMembership:
+    """One stock's industries and concepts as observed on one snapshot date.
+
+    ``trade_date`` is the actual membership snapshot date, which is the newest
+    successful build at or before the requested date; it must never be
+    substituted with a newer snapshot.
+    """
+
+    status: ReadStatus
+    query: StockSectorQuery
+    trade_date: date | None
+    industries: tuple[SectorRef, ...]
+    concepts: tuple[SectorRef, ...]
+    concept_total: int
+
+
 _METRIC_DEFINITIONS = {
     MetricKind.AMOUNT: RadarMetricDefinition(
         metric_kind=MetricKind.AMOUNT,
@@ -212,6 +259,48 @@ class ReadSectorRadar:
             total=len(searched),
         )
 
+    def stock_membership(self, query: StockSectorQuery) -> StockSectorMembership:
+        """Return one stock's sectors from the strict last-good build snapshot."""
+
+        publication = self.repository.get_last_good_publication(query.trade_date)
+        if publication is None:
+            return StockSectorMembership(
+                status="no_data",
+                query=query,
+                trade_date=None,
+                industries=(),
+                concepts=(),
+                concept_total=0,
+            )
+        entries = self.repository.load_stock_memberships(
+            publication.target_trade_date, query.ts_code
+        )
+        industries = _sector_refs(
+            entry for entry in entries if entry.sector_type is SectorType.INDUSTRY
+        )
+        concepts = _sector_refs(
+            entry for entry in entries if entry.sector_type is SectorType.CONCEPT
+        )
+        return StockSectorMembership(
+            status="success",
+            query=query,
+            trade_date=publication.target_trade_date,
+            industries=industries,
+            concepts=concepts[: query.concept_limit],
+            concept_total=len(concepts),
+        )
+
+
+def _sector_refs(entries: Iterator[StockMembershipEntry]) -> tuple[SectorRef, ...]:
+    """Project membership entries into ordered public sector references."""
+
+    return tuple(
+        sorted(
+            (SectorRef(code=entry.sector_code, name=entry.sector_name) for entry in entries),
+            key=lambda ref: (ref.code, ref.name),
+        )
+    )
+
 
 __all__ = [
     "RadarDateIndex",
@@ -220,4 +309,8 @@ __all__ = [
     "RadarView",
     "RankingPage",
     "ReadSectorRadar",
+    "SectorRef",
+    "StockSectorMembership",
+    "StockSectorQuery",
+    "STOCK_SECTOR_CONCEPT_LIMIT",
 ]

zhixing-server/src/zhixing_server/modules/sector_radar/domain/persistence.py

@@ -65,6 +65,22 @@ class MembershipRecord:
         return self.stock_code if self.stock_code is not None else "__membership_unknown__"
 
 
+@dataclass(frozen=True, slots=True)
+class StockMembershipEntry:
+    """One sector that claimed a stock on exactly one snapshot trade date."""
+
+    trade_date: date
+    sector_type: SectorType
+    sector_code: str
+    sector_name: str
+
+    def __post_init__(self) -> None:
+        """Reject empty sector identity fields."""
+
+        if not self.sector_code.strip() or not self.sector_name.strip():
+            raise ValueError("membership sector identity fields must not be empty")
+
+
 @dataclass(frozen=True, slots=True)
 class StockFactRecord:
     """One normalized stock fact revision with all contributing raw snapshots."""
@@ -197,6 +213,10 @@ class SectorRadarRepository(Protocol):
 
     def save_memberships(self, records: Iterable[MembershipRecord]) -> WriteCounts: ...
 
+    def load_stock_memberships(
+        self, trade_date: date, stock_code: str
+    ) -> Sequence[StockMembershipEntry]: ...
+
     def save_stock_facts(self, records: Iterable[StockFactRecord]) -> WriteCounts: ...
 
     def save_daily_aggregates(self, records: Iterable[DailyAggregateRecord]) -> WriteCounts: ...

zhixing-server/src/zhixing_server/modules/sector_radar/infrastructure/memory.py

@@ -15,6 +15,7 @@ from ..domain.persistence import (
     PublicationSourceRecord,
     RankingRecord,
     StockFactRecord,
+    StockMembershipEntry,
     WriteCounts,
 )
 from ..domain.source import SourceSnapshot
@@ -115,6 +116,27 @@ class InMemorySectorRadarRepository:
             ),
         )
 
+    def load_stock_memberships(
+        self, trade_date: date, stock_code: str
+    ) -> Sequence[StockMembershipEntry]:
+        """Return available sectors that claimed one stock on one snapshot date."""
+
+        return tuple(
+            StockMembershipEntry(
+                trade_date=record.trade_date,
+                sector_type=record.sector_type,
+                sector_code=record.sector_code,
+                sector_name=record.sector_name,
+            )
+            for record in sorted(
+                self.memberships.values(),
+                key=lambda item: (item.sector_type, item.sector_code),
+            )
+            if record.trade_date == trade_date
+            and record.stock_code == stock_code
+            and record.status.value == "available"
+        )
+
     def save_stock_facts(self, records: Iterable[StockFactRecord]) -> WriteCounts:
         """Insert normalized fact revisions idempotently."""
 

zhixing-server/src/zhixing_server/modules/sector_radar/infrastructure/postgres.py

@@ -31,6 +31,7 @@ from ..domain.persistence import (
     PublicationSourceRecord,
     RankingRecord,
     StockFactRecord,
+    StockMembershipEntry,
     WriteCounts,
 )
 from ..domain.source import SourceSnapshot
@@ -283,6 +284,32 @@ class PostgresSectorRadarRepository:
             rows,
         )
 
+    def load_stock_memberships(
+        self, trade_date: date, stock_code: str
+    ) -> Sequence[StockMembershipEntry]:
+        """Load every sector that claimed one stock on exactly one snapshot date."""
+
+        with self._connection() as connection:
+            rows = connection.execute(
+                """
+                SELECT trade_date, sector_type, sector_code, sector_name
+                FROM sector_radar_membership
+                WHERE trade_date = %s AND stock_code = %s
+                  AND membership_status = 'available'
+                ORDER BY sector_type, sector_code
+                """,
+                (trade_date, stock_code),
+            ).fetchall()
+        return tuple(
+            StockMembershipEntry(
+                trade_date=row[0],
+                sector_type=SectorType(row[1]),
+                sector_code=row[2],
+                sector_name=row[3],
+            )
+            for row in rows
+        )
+
     def save_stock_facts(self, records: Iterable[StockFactRecord]) -> WriteCounts:
         """COPY normalized stock facts while preserving contributing source ids."""
 

zhixing-server/src/zhixing_server/modules/sector_radar/presentation/http.py

@@ -8,17 +8,21 @@ from datetime import date, datetime
 from decimal import Decimal
 from typing import Annotated, Literal
 
-from fastapi import APIRouter, Depends, HTTPException, Query
+from fastapi import APIRouter, Depends, HTTPException, Path, Query
 from pydantic import BaseModel, Field
 
 from ....bootstrap.config import Settings, get_settings
 from ..application.read import (
+    STOCK_SECTOR_CONCEPT_LIMIT,
     RadarDateIndex,
     RadarMetricDefinition,
     RadarQuery,
     RadarView,
     RankingPage,
     ReadSectorRadar,
+    SectorRef,
+    StockSectorMembership,
+    StockSectorQuery,
 )
 from ..domain.models import (
     MetricKind,
@@ -122,6 +126,29 @@ class RadarRankingsResponse(BaseModel):
     rows: list[RadarRankingRowResponse] = Field(default_factory=_empty_ranking_rows)
 
 
+class SectorRefResponse(BaseModel):
+    """Public identity of one sector that claimed a stock."""
+
+    code: str
+    name: str
+
+
+class StockSectorMembershipResponse(BaseModel):
+    """One stock's point-in-time industries and concepts from last-good build.
+
+    ``trade_date`` is the actual membership snapshot date, never a newer one.
+    """
+
+    status: Literal["success", "no_data"]
+    ts_code: str
+    requested_trade_date: date
+    trade_date: date | None
+    industries: list[SectorRefResponse] = Field(default_factory=list)
+    concepts: list[SectorRefResponse] = Field(default_factory=list)
+    concept_total: int = Field(ge=0)
+    concept_limit: int = Field(ge=1, le=100)
+
+
 def get_sector_radar_reader(
     settings: Annotated[Settings, Depends(get_settings)],
 ) -> ReadSectorRadar:
@@ -196,6 +223,28 @@ def get_sector_radar_rankings(
         raise _storage_error() from exc
 
 
+@sector_radar_router.get(
+    "/stocks/{ts_code}/membership", response_model=StockSectorMembershipResponse
+)
+def get_stock_sector_membership(
+    reader: Annotated[ReadSectorRadar, Depends(get_sector_radar_reader)],
+    ts_code: Annotated[str, Path(min_length=1, max_length=12)],
+    trade_date: date,
+    concept_limit: Annotated[int, Query(ge=1, le=100)] = STOCK_SECTOR_CONCEPT_LIMIT,
+) -> StockSectorMembershipResponse:
+    """Return one stock's industries and concepts from the last-good snapshot."""
+
+    query = StockSectorQuery(
+        trade_date=trade_date,
+        ts_code=ts_code.strip(),
+        concept_limit=concept_limit,
+    )
+    try:
+        return _stock_membership_response(reader.stock_membership(query))
+    except SectorRadarRepositoryError as exc:
+        raise _storage_error() from exc
+
+
 def _dates_response(index: RadarDateIndex) -> RadarDatesResponse:
     return RadarDatesResponse(
         status=index.status,
@@ -231,6 +280,25 @@ def _rankings_response(page: RankingPage) -> RadarRankingsResponse:
     )
 
 
+def _stock_membership_response(
+    membership: StockSectorMembership,
+) -> StockSectorMembershipResponse:
+    return StockSectorMembershipResponse(
+        status=membership.status,
+        ts_code=membership.query.ts_code,
+        requested_trade_date=membership.query.trade_date,
+        trade_date=membership.trade_date,
+        industries=[_sector_ref_response(ref) for ref in membership.industries],
+        concepts=[_sector_ref_response(ref) for ref in membership.concepts],
+        concept_total=membership.concept_total,
+        concept_limit=membership.query.concept_limit,
+    )
+
+
+def _sector_ref_response(ref: SectorRef) -> SectorRefResponse:
+    return SectorRefResponse(code=ref.code, name=ref.name)
+
+
 def _publication_response(publication: RadarPublication) -> RadarPublicationResponse:
     return RadarPublicationResponse(
         publication_id=publication.publication_id,
@@ -297,6 +365,7 @@ def _storage_error() -> HTTPException:
 __all__ = [
     "RadarDatesResponse",
     "RadarRankingsResponse",
+    "StockSectorMembershipResponse",
     "get_sector_radar_reader",
     "sector_radar_router",
 ]

zhixing-server/tests/test_sector_radar_http.py

@@ -13,6 +13,9 @@ from zhixing_server.modules.sector_radar.application.read import (
     RadarQuery,
     RadarView,
     RankingPage,
+    SectorRef,
+    StockSectorMembership,
+    StockSectorQuery,
 )
 from zhixing_server.modules.sector_radar.domain.metrics import AmountNetStrategy
 from zhixing_server.modules.sector_radar.domain.models import (
@@ -87,7 +90,9 @@ def _ranking() -> RankedMetric:
 class FakeReader:
     def __init__(self, *, no_data: bool = False, fail: bool = False) -> None:
         self.fail = fail
+        self.no_data = no_data
         self.last_query: RadarQuery | None = None
+        self.last_membership_query: StockSectorQuery | None = None
         success = _publication("publication-success", PublicationStatus.SUCCESS)
         current = _publication(
             "publication-partial",
@@ -125,6 +130,32 @@ class FakeReader:
         self.last_query = query
         return replace(self.page, query=query)
 
+    def stock_membership(self, query: StockSectorQuery) -> StockSectorMembership:
+        if self.fail:
+            raise SectorRadarRepositoryError("private database detail")
+        self.last_membership_query = query
+        if self.no_data:
+            return StockSectorMembership(
+                status="no_data",
+                query=query,
+                trade_date=None,
+                industries=(),
+                concepts=(),
+                concept_total=0,
+            )
+        return StockSectorMembership(
+            status="success",
+            query=query,
+            trade_date=TARGET_DATE,
+            industries=(SectorRef(code="BK0901.DC", name="银行"),),
+            concepts=(
+                SectorRef(code="BK0001.DC", name="机器人"),
+                SectorRef(code="BK0002.DC", name="人工智能"),
+                SectorRef(code="BK0003.DC", name="数字经济"),
+            ),
+            concept_total=3,
+        )
+
 
 def _client(reader: FakeReader) -> TestClient:
     application = create_app()
@@ -228,3 +259,78 @@ def test_repository_error_maps_to_redacted_503() -> None:
         }
     }
     assert "private database detail" not in response.text
+
+
+def test_stock_membership_maps_industries_and_concepts() -> None:
+    reader = FakeReader()
+    response = _client(reader).get(
+        "/api/v1/sector-radar/stocks/000001.SZ/membership",
+        params={"trade_date": "2026-08-28"},
+    )
+
+    assert response.status_code == 200
+    assert reader.last_membership_query == StockSectorQuery(
+        trade_date=TARGET_DATE,
+        ts_code="000001.SZ",
+    )
+    payload = response.json()
+    assert payload["status"] == "success"
+    assert payload["ts_code"] == "000001.SZ"
+    assert payload["requested_trade_date"] == "2026-08-28"
+    assert payload["trade_date"] == "2026-08-28"
+    assert payload["industries"] == [{"code": "BK0901.DC", "name": "银行"}]
+    assert payload["concept_total"] == 3
+    assert payload["concept_limit"] == 20
+    assert [concept["code"] for concept in payload["concepts"]] == [
+        "BK0001.DC",
+        "BK0002.DC",
+        "BK0003.DC",
+    ]
+
+
+def test_stock_membership_no_data_is_a_stable_200_response() -> None:
+    response = _client(FakeReader(no_data=True)).get(
+        "/api/v1/sector-radar/stocks/000001.SZ/membership",
+        params={"trade_date": "2026-08-28"},
+    )
+
+    assert response.status_code == 200
+    payload = response.json()
+    assert payload["status"] == "no_data"
+    assert payload["trade_date"] is None
+    assert payload["industries"] == []
+    assert payload["concepts"] == []
+    assert payload["concept_total"] == 0
+
+
+def test_stock_membership_rejects_invalid_query_values() -> None:
+    client = _client(FakeReader())
+
+    missing_date = client.get("/api/v1/sector-radar/stocks/000001.SZ/membership")
+    bad_limit = client.get(
+        "/api/v1/sector-radar/stocks/000001.SZ/membership",
+        params={"trade_date": "2026-08-28", "concept_limit": 0},
+    )
+    over_limit = client.get(
+        "/api/v1/sector-radar/stocks/000001.SZ/membership",
+        params={"trade_date": "2026-08-28", "concept_limit": 101},
+    )
+    empty_code = client.get(
+        "/api/v1/sector-radar/stocks//membership", params={"trade_date": "2026-08-28"}
+    )
+
+    assert missing_date.status_code == 422
+    assert bad_limit.status_code == 422
+    assert over_limit.status_code == 422
+    assert empty_code.status_code in (404, 422)
+
+
+def test_stock_membership_repository_error_maps_to_redacted_503() -> None:
+    response = _client(FakeReader(fail=True)).get(
+        "/api/v1/sector-radar/stocks/000001.SZ/membership",
+        params={"trade_date": "2026-08-28"},
+    )
+
+    assert response.status_code == 503
+    assert response.json()["detail"]["code"] == "sector_radar_storage_unavailable"
+    assert "private database detail" not in response.text

zhixing-server/tests/unit/sector_radar/test_read.py

@@ -2,10 +2,14 @@ from dataclasses import replace
 from datetime import UTC, date, datetime, timedelta
 from decimal import Decimal
 
+import pytest
+
 from zhixing_server.modules.sector_radar.application.read import (
     RadarQuery,
     RadarView,
     ReadSectorRadar,
+    SectorRef,
+    StockSectorQuery,
 )
 from zhixing_server.modules.sector_radar.domain.metrics import AmountNetStrategy
 from zhixing_server.modules.sector_radar.domain.models import (
@@ -20,7 +24,10 @@ from zhixing_server.modules.sector_radar.domain.models import (
     RankSide,
     SectorType,
 )
-from zhixing_server.modules.sector_radar.domain.persistence import RankingRecord
+from zhixing_server.modules.sector_radar.domain.persistence import (
+    MembershipRecord,
+    RankingRecord,
+)
 from zhixing_server.modules.sector_radar.domain.ranking import rank_metric_observations
 from zhixing_server.modules.sector_radar.infrastructure.memory import (
     InMemorySectorRadarRepository,
@@ -187,3 +194,124 @@ def test_latest_partial_attempt_is_visible_but_does_not_replace_last_good() -> N
     assert index.last_good is not None
     assert index.last_good.publication_id == "publication-success"
     assert index.available_dates == (TARGET_DATE,)
+
+
+def _membership_record(
+    stock_code: str,
+    sector_type: SectorType,
+    sector_code: str,
+    sector_name: str,
+    *,
+    trade_date: date = TARGET_DATE,
+) -> MembershipRecord:
+    return MembershipRecord(
+        source_snapshot_id="b" * 64,
+        trade_date=trade_date,
+        sector_type=sector_type,
+        sector_code=sector_code,
+        sector_name=sector_name,
+        stock_code=stock_code,
+        stock_name="测试股票",
+    )
+
+
+def _membership_repository() -> InMemorySectorRadarRepository:
+    repository = _published_repository()
+    repository.save_memberships(
+        (
+            _membership_record("000001.SZ", SectorType.INDUSTRY, "BK0902.DC", "房地产"),
+            _membership_record("000001.SZ", SectorType.CONCEPT, "BK0003.DC", "数字经济"),
+            _membership_record("000001.SZ", SectorType.CONCEPT, "BK0001.DC", "机器人"),
+            _membership_record("000001.SZ", SectorType.CONCEPT, "BK0002.DC", "人工智能"),
+            _membership_record("000002.SZ", SectorType.INDUSTRY, "BK0901.DC", "银行"),
+        )
+    )
+    return repository
+
+
+def test_stock_membership_groups_types_and_orders_by_sector_code() -> None:
+    reader = ReadSectorRadar(_membership_repository())
+
+    membership = reader.stock_membership(
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="000001.SZ")
+    )
+
+    assert membership.status == "success"
+    assert membership.trade_date == TARGET_DATE
+    assert membership.industries == (SectorRef(code="BK0902.DC", name="房地产"),)
+    assert [ref.code for ref in membership.concepts] == [
+        "BK0001.DC",
+        "BK0002.DC",
+        "BK0003.DC",
+    ]
+    assert membership.concept_total == 3
+    other = reader.stock_membership(StockSectorQuery(trade_date=TARGET_DATE, ts_code="000002.SZ"))
+    assert other.industries == (SectorRef(code="BK0901.DC", name="银行"),)
+    assert other.concepts == ()
+    assert other.concept_total == 0
+
+
+def test_stock_membership_truncates_concepts_with_total_preserved() -> None:
+    reader = ReadSectorRadar(_membership_repository())
+
+    membership = reader.stock_membership(
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="000001.SZ", concept_limit=2)
+    )
+
+    assert [ref.code for ref in membership.concepts] == ["BK0001.DC", "BK0002.DC"]
+    assert membership.concept_total == 3
+
+
+def test_stock_membership_uses_newest_build_at_or_before_requested_date() -> None:
+    repository = _membership_repository()
+    earlier = _running("publication-earlier", TARGET_DATE - timedelta(days=1))
+    repository.create_publication(earlier)
+    repository.finish_publication(_finish(earlier, PublicationStatus.SUCCESS))
+    repository.save_memberships(
+        (
+            _membership_record(
+                "000001.SZ",
+                SectorType.INDUSTRY,
+                "BK0899.DC",
+                "旧行业",
+                trade_date=TARGET_DATE - timedelta(days=1),
+            ),
+        )
+    )
+    reader = ReadSectorRadar(repository)
+
+    membership = reader.stock_membership(
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="000001.SZ")
+    )
+
+    assert membership.trade_date == TARGET_DATE
+    assert membership.industries == (SectorRef(code="BK0902.DC", name="房地产"),)
+    behind = reader.stock_membership(
+        StockSectorQuery(trade_date=TARGET_DATE - timedelta(days=1), ts_code="000001.SZ")
+    )
+    assert behind.trade_date == TARGET_DATE - timedelta(days=1)
+    assert behind.industries == (SectorRef(code="BK0899.DC", name="旧行业"),)
+    assert behind.concepts == ()
+
+
+def test_stock_membership_without_any_publication_is_no_data() -> None:
+    reader = ReadSectorRadar(InMemorySectorRadarRepository())
+
+    membership = reader.stock_membership(
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="000001.SZ")
+    )
+
+    assert membership.status == "no_data"
+    assert membership.trade_date is None
+    assert membership.industries == ()
+    assert membership.concepts == ()
+    assert membership.concept_total == 0
+
+
+def test_stock_membership_query_rejects_invalid_values() -> None:
+    with pytest.raises(ValueError):
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="  ")
+    with pytest.raises(ValueError):
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="x" * 13)
+    with pytest.raises(ValueError):
+        StockSectorQuery(trade_date=TARGET_DATE, ts_code="000001.SZ", concept_limit=0)