fix(HEL-72): [hidden] 规则强制 display:none，修复 tabbar/返回键被 display 顶掉

Co-authored-by: multica-agent <github@multica.ai>

AGENTS.md

@@ -1,23 +1,15 @@
-# 小白复盘仓库执行约束
+# 小白复盘仓库过渡期约束
 
-本文件对仓库内所有后续编码任务生效。任何智能体在修改文件前必须完整读取：
+`app/`是已完成人工验收的正式源码，也是后续开发的唯一实现。修改`app/`前必须完整读取
+`app/AGENTS.md`、`app/ARCHITECTURE.md`及与任务有关的测试和注册表。
 
-1. `docs/migration/原版保真迁移总纲.md`
-2. `docs/migration/保真迁移状态.json`
-3. `docs/migration/next失败冻结记录.md`
-4. 与本次功能有关的原版源码、页面和测试
+根目录旧程序和`next/`只用于本次最终清理前的Git回档，不得继续开发、部署或被`app/`导入。
+永久产品、治理、迁移和维护文档已经归入`app/docs/`。
 
 ## 不可违反
 
-- 当前根目录原版是唯一功能、视觉、交互、动画和计算基线。
-- `next/`是失败冻结实现，禁止部署、继续开发或作为新迁移代码来源。
-- 后续迁移是原代码保真式整理，不是重写、重新设计或更换技术栈。
-- 不得根据规格说明书重新实现已经存在的功能；规格书只用于盘点，冲突必须交给用户裁决。
-- 不得改变用户可观察行为。源码可以移动、拆分和调整引用，但输出必须等价。
-- 不确定是否有用的代码默认保留。没有引用扫描、运行证据和新旧对比，不得删除。
-- 每次只处理一个完整纵向功能切片，并同步更新迁移账本和状态文件。
-- 每个切片必须具有原版基线、新版结果、API/数据库对比、页面与交互对比及Git回档点。
-- 不以新实现自身测试通过、目录更整齐或代码行数减少证明迁移成功。
-- 未经用户人工确认，不得宣称视觉等价、完成迁移、切换Docker/NAS或删除原版。
-
-如果任务要求与以上约束冲突，停止迁移并向用户说明冲突，不自行选择新产品行为。
+- 不得从根目录旧程序或`next/`复制实现覆盖`app/`。
+- 不得改变用户已经验收的功能、视觉、交互、动画、计算和数据语义。
+- 不得提交Token、密码、`.env`、数据库、私有Skill、日志、缓存或测试产物。
+- 删除旧目录前必须先完成`app/`独立验证并建立可推送的Git回档提交。
+- 根目录清理只删除已经被`app/`替代且没有剩余消费者的内容，不顺带修改产品行为。

app/.dockerignore

@@ -7,6 +7,7 @@
 __pycache__/
 *.py[cod]
 *.log
+runtime/
 data/cache/
 data/private-mentor-skills/
 data/*.db

app/.gitignore

@@ -15,11 +15,6 @@ data/*.backup
 .coverage
 htmlcov/
 .pytest_cache/
-test-results/
-playwright-report/
+runtime/*
+!runtime/.gitignore
 node_modules/
-next/.venv/
-next/data/
-next/frontend/dist/
-next/frontend/.vite/
-next/frontend/coverage/

app/AGENTS.md

@@ -0,0 +1,37 @@
+# 小白复盘维护约束
+
+本目录是小白复盘唯一正式源码。任何修改开始前必须读取：
+
+1. `ARCHITECTURE.md`
+2. `docs/product/小白复盘-完整产品规格说明书.md`
+3. 与任务有关的`config/*.json`、源码和测试
+
+`docs/migration/`保存迁移事实与历史证据，不是第二套产品实现。发生冲突时，依次以用户当前明确
+决定、当前正式程序的真实行为、产品规格说明书为准。
+
+## 产品边界
+
+- 保持已经验收的功能、视觉、布局、动画、交互、响应式行为和日夜主题。
+- 保持API路径、字段、状态码、流式协议、数据库兼容和账户隔离。
+- 保持数据来源、日期、单位、复权、新鲜度、覆盖率和禁止静默降级规则。
+- LLM只通过`backend/llm/`调用；浏览器请求只通过`frontend/shared/api.js`发出。
+- 不得读取、导入或运行本目录父级的旧源码、静态资源、配置、测试或数据。
+
+## 结构边界
+
+- 保持模块化单体技术栈：一个Python进程、一个SQLite数据库、无构建前端。
+- 业务代码进入`backend/features/<feature>/`，数据适配进入`backend/data/`，后台任务进入
+  `backend/jobs/`，HTTP公共能力进入`backend/http/`。
+- 页面结构、行为和样式分别由`frontend/pages/<feature>/`及`frontend/shared/`的唯一所有者维护。
+- 不建立根级兼容转发文件、第二套路由、第二套数据客户端或晚加载CSS补丁层。
+- 不确定代码默认保留；删除前必须有引用扫描、测试和真实浏览器证据。
+
+## 最低验收
+
+1. 运行相关领域测试。
+2. 运行`python tools/verify_baseline.py`。
+3. 涉及运行时或前端时运行`python tools/verify_baseline.py --e2e`。
+4. 检查`git diff --check`，并确认没有密钥、数据库和运行产物进入Git。
+5. 用户可观察行为发生变化时，必须说明并由用户验收。
+
+数据和`.env`必须成对备份。`data/private-mentor-skills/`、`data/*.db`、`runtime/`及`.env`不得提交。

app/ARCHITECTURE.md

@@ -1,40 +1,185 @@
-# Architecture
+# Application architecture
 
-The normative governance contract is documented in
-`docs/governance/architecture-standard.md`. This file describes the currently deployed
-shape; the standard defines the target boundaries and the rules applied during migration.
+`app/` is the standalone, behavior-preserving modular source tree accepted by the user on
+2026-08-01. It is the only production source boundary and must not read or import a parent
+checkout, a retired baseline, or a failed implementation.
 
-The application intentionally keeps a small deployment footprint: one Python process, one
-SQLite database, and a build-free browser client. The internal boundaries are nevertheless
-explicit so new features do not bypass account isolation or data-quality rules.
+The application deliberately remains a modular monolith: one Python process, one SQLite WAL
+database, and a build-free HTML/CSS/JavaScript client. The migration changed source ownership
+and imports, not the technology stack or observable product behavior.
 
-## Backend boundaries
+## Runtime path
 
-- `server.py`: application services and HTTP request/response wiring.
-- `api_access.py`: the single authorization policy for authenticated, member, and admin APIs.
-- `app_config.py`: runtime paths, local environment loading, and shared input validation.
-- `database.py`: SQLite schema, migrations, and persistence operations.
-- `tushare_client.py` and `realtime_aggregator.py`: external market-data adapters.
-- `sentiment_engine.py`, `screener.py`, and `heaven_engine.py`: deterministic domain logic.
-- `mentor_agent.py`, `heaven_agent.py`, and `llm_strategy.py`: bounded LLM adapters.
+```text
+browser
+  -> frontend/shared/api.js
+  -> backend HTTP transport and feature HTTP mixins
+  -> feature services
+  -> repositories / DataGateway / LLMGateway
+  -> SQLite / market providers / model providers
 
-## Data ownership
+background scheduler
+  -> backend/jobs
+  -> the same feature services and repositories
+```
 
-Public market snapshots, stock factors, built-in strategies, limit-up reasons, seat aliases,
-and sector-element mappings are shared. Only administrators can modify shared knowledge.
+## Source ownership
 
-Watchlists, review notes, custom strategies, screener runs, mentor conversations, birth data,
-alerts, trading journals, and assistant conversations are owned by a user ID and must be
-queried with that ID. LLM features additionally require active membership.
+- `server.py` is the stable command/import facade. `backend/application.py` is the narrow
+  composition root for `DashboardService`, `RequestHandler`, and the process-wide service
+  instance; dependency construction remains in `backend/bootstrap/`.
+- `backend/bootstrap/` owns process configuration, dependency construction, startup, and
+  shared input/display-format contracts. It does not own feature behavior.
+- `backend/http/` owns common authentication, request IDs, JSON/NDJSON responses, static
+  delivery, streaming connection lifecycle, and error normalization. Feature-specific
+  transport handlers live beside their feature. `backend/http/dispatch.py` owns only public
+  versus authenticated guard order, named POST dispatch, feature-route traversal, static
+  fallback, and final 404 responses. Exact POST maps live there; endpoint parsing, response
+  fields, and feature-specific exceptions belong to `backend/features/<feature>/routes.py`.
+- `backend/features/<feature>/` owns the mechanically moved service, repository, HTTP, agent,
+  or deterministic calculation code for that product area.
+- `backend/data/` owns provider construction, source policy, provenance, units, freshness,
+  coverage, display-versus-calculation eligibility, and shared numeric normalization policies.
+- `backend/data/providers/tushare_client.py` is the stable public `TushareClient` facade and
+  owns only its dataclass fields and shared cache state. Tushare HTTP transport belongs to
+  `tushare_transport.py`; market overview and realtime breadth belong to
+  `tushare_dashboard.py`; indices belong to `tushare_indices.py`; Shenwan membership and
+  industry snapshots belong to `tushare_industries.py`; generic sector snapshots belong to
+  `tushare_sectors.py`; hot-money and dragon-tiger data belong to
+  `tushare_dragon_tiger.py`; stock detail and intraday data belong to `tushare_stocks.py`;
+  trading-calendar, daily, and limit-list access belong to `tushare_daily.py`; small shared
+  deterministic conversions belong to `tushare_helpers.py`.
+- `backend/database/` owns connection management, ordered migrations, and narrow repository
+  adapters. Root `database.py` remains the legacy schema/composition anchor and combines the
+  feature repository mixins; do not add feature queries to it.
+- `backend/jobs/` owns job definitions, locks, retries, idempotency, and persisted run state.
+  `backend/jobs/service.py` is the application-facing owner of scheduler start/stop, manual
+  refresh submission, and periodic refresh coordination.
+- `backend/llm/` owns model selection, membership/quota checks, fallback, provider transport,
+  streaming rules, and call audit. Feature agents only prepare messages and interpret
+  feature-specific results.
+- `frontend/index.html` owns only the login layer, application Shell, overview strip, status
+  bar, global dialogs, and the single page-fragment mount point. `frontend/bootstrap.js`
+  loads the registered page fragments before the unchanged application runtime starts.
+- `frontend/pages.config.js` is the only runtime owner of page-fragment paths and script
+  execution order. Do not add page scripts directly to `index.html` or create another loader.
+- `frontend/app.js` is only the browser startup coordinator: initialize controls, resolve the
+  initial route, start the authenticated application, and invoke registered binding owners.
+  It must not own feature event handlers, dashboard rendering, account/admin behavior, theme
+  behavior, table behavior, or application state definitions.
+- `frontend/shared/` is the only browser data-API/state/Shell/component boundary. Within it,
+  `context.js` owns application state and DOM handles, `application.js` owns API/Shell/page
+  lifecycle composition, `feedback.js` owns common feedback and motion, `dashboard.js` owns
+  market-dashboard refresh and date coordination, `session.js` owns authentication/account
+  access, `admin.js` owns system administration, `theme.js` owns theme switching, and
+  `table.js` owns generic table behavior. The Bootstrap fetch is limited to registered
+  same-origin static HTML fragments.
+- `frontend/pages/` owns page-local markup, behavior, and styles through `page.html`,
+  `page.js`, and `foundation.css`. Each feature registers its own one-time control binder with
+  the page runtime; feature selectors and event handlers must not be added to `app.js`. The
+  original DOM and runtime were split mechanically during migration. Current maintenance is
+  governed by the runtime registry, unique symbol owners, DOM/API contracts, JavaScript syntax
+  checks, and Playwright behavior rather than embedded historical source ranges.
+- `frontend/pages/market/` owns cross-page market presentation through narrow runtime modules:
+  `breadth.js`, `charts.js`, `entity-detail.js`, `stock-detail.js`, `preview.js`, `search.js`,
+  and `bindings.js`. `runtime.js` is retired; do not recreate a combined market runtime or a
+  compatibility loader. `pages.config.js` is the sole owner of their execution order.
+- `backend/features/screener/engine.py` is the stable screener compatibility facade only.
+  Screener declarations belong to `catalog.py`; external factor synchronization belongs to
+  `data_sync.py`; deterministic technical and statistical helpers belong to `indicators.py`;
+  factor construction belongs to `factors.py`; formula validation, scoring, and local strategy
+  compilation belong to `formula.py`; market-phase identification belongs to `regime.py`;
+  screening execution and result persistence belong to `selection.py`; historical evaluation
+  belongs to `backtest.py`.
+- `backend/features/heaven/service.py` is the stable Wentian service facade only. Manual
+  six-line input validation and safety gates belong to `manual.py`; trend setup, market mode,
+  source disclosure, and quality checks belong to `trend.py`; stock, index, and sector context
+  collection belongs to `market_context.py`; personal fields, hexagrams, saved readings, and
+  interpretation orchestration belong to `readings.py`; deterministic Jing Fang Na Jia, eight
+  palaces, six relatives, self/response, six spirits, calendar relations, and hidden spirits
+  belong to `six_yao.py`; source-traceable Wentian knowledge retrieval and the only LLM-bound
+  context projection belong to `knowledge.py`; prompt construction and answer validation remain
+  in `agent.py`. These owners cooperate through the composed service object and do not duplicate
+  or delegate method bodies through the facade.
+- Application-facing system credentials, data/LLM status, and administrator settings belong
+  to `backend/features/system/service.py`; account-context delegation belongs to
+  `backend/features/accounts/application.py`. They are composed into `DashboardService` and
+  must not return to the composition root.
+- `backend/features/market/insights.py` is the stable public `MarketInsightsService` facade
+  only. Shared construction, trading context, stock master access, and concept parsing belong
+  to `insights_context.py`; auction scoring and candidate construction belong to
+  `insights_auction_scoring.py`; auction session, amount history, watchlist enrichment, and
+  live snapshots belong to `insights_auction_data.py`; auction result orchestration belongs to
+  `insights_auction.py`; theme library/detail behavior belongs to `insights_themes.py`; and hot
+  ranking behavior belongs to `insights_popularity.py`.
+- `frontend/shared/tokens.css` owns global design semantics. Shared foundations live in
+  `frontend/shared/*.css` and `frontend/shared/components/*.css`; page foundations live beside
+  their page in `frontend/pages/<feature>/foundation.css`. These 22 files replace the retired
+  `frontend/styles/styles.css`, four historical refinement layers, and the former Wentian
+  page stylesheet. Production loads only this canonical stack: every selector/context pair has
+  one owner, shared roots stay in shared files, and page-scoped rules stay beside their page.
+- `config/` is the versioned registry for pages, features, APIs, datasets, quality rules,
+  jobs, and the generated candidate architecture inventory.
 
-## Data integrity
+The source root has four Python entry modules only: `server.py` starts and exports the process
+surface, `database.py` remains the documented schema/composition anchor, `api_access.py` owns
+the route-access registry entry, and `sync_data.py` is the manual synchronization command.
+The 19 migration-only import aliases were retired after all internal and test consumers moved
+to canonical `backend/` owners. Do not recreate root-level feature import shims.
 
-Production reads never synthesize market prices. A failed live request may use the latest real
-snapshot at or before the requested date. When no real snapshot exists, the API reports that
-the data is unavailable. Demo builders remain test fixtures only.
+Generated local artifacts belong under `runtime/`: server output in `runtime/logs`, Python
+cache in `runtime/cache`, and browser artifacts in `runtime/test-results`. Docker continues to
+emit logs through its configured logging driver instead of writing into the source tree.
 
-## Change contract
+## Non-negotiable maintenance rules
 
-New endpoints must be added to `api_access.required_role` when they need member or admin
-access. New user-owned tables must include `user_id`, an ownership index, and cross-account
-tests. API payload compatibility is protected by the Python and Playwright suites.
+1. Preserve account ownership in every user-private query and test it with two accounts.
+2. Browser business-data requests go through `frontend/shared/api.js`; only
+   `frontend/bootstrap.js` may fetch registered static page fragments. Provider calls go
+   through the data boundary; model calls go through `backend/llm/`.
+3. Calculation datasets fail closed when required source, date, unit, freshness, or coverage
+   evidence is missing. Display fallbacks do not silently enter calculations.
+4. Do not create root-level feature compatibility modules; import the canonical `backend/`
+   owner directly.
+5. Do not remove uncertain code without reference scanning, old/new differential evidence,
+   browser checks, and manual acceptance.
+6. Run `python tools/verify_baseline.py` for every change and add `--e2e` when runtime or
+   frontend behavior can be affected.
+7. Do not recreate late-loading `legacy.css`, `override.css`, `fix.css`, or page-wide patch
+   layers. Change the canonical shared or page owner and keep the CSS ownership tests green.
+8. Do not put `workspace-view` roots back into `frontend/index.html`. Add or change page DOM
+   only in its registered `frontend/pages/<feature>/page.html`, without introducing a second
+   fragment or runtime-script registry.
+9. Do not add feature selectors, feature event listeners, shared state declarations, or
+   shared service implementations to `frontend/app.js`; extend the existing unique owner and
+   keep the startup-entry boundary tests green.
+10. Do not merge market charts, previews, search, stock details, entity details, breadth, and
+    event binding back into one runtime file. Keep each definition in its registered owner and
+    keep the market runtime ownership test green.
+11. Do not merge screener catalogs, data synchronization, indicators, factor construction,
+    formulas, regime detection, selection, and backtesting back into one engine. Keep
+    `backend/features/screener/engine.py` as a compatibility facade and preserve one canonical
+    owner for each responsibility.
+12. Do not merge Tushare transport, dashboard, indices, Shenwan industries, sectors,
+    dragon-tiger data, stock detail, and daily-market access back into one client. Keep
+    `backend/data/providers/tushare_client.py` as the single public class facade, and do not
+    duplicate provider method bodies in that facade or another compatibility module.
+13. Do not merge Wentian manual validation, trend orchestration, market-context collection,
+    and reading/LLM behavior back into one service. Keep
+    `backend/features/heaven/service.py` as a method-free composition facade and preserve one
+    canonical owner for every Wentian service method.
+14. Do not merge auction scoring, auction data preparation, auction orchestration, themes,
+    popularity, and shared insight context back into one market-insights service. Keep
+    `backend/features/market/insights.py` as a method-free public facade and preserve one
+    canonical owner for every market-insight method.
+15. Do not put feature route bodies, system settings behavior, account delegation, or job
+    lifecycle methods back into `backend/application.py`. Keep it as a composition root; keep
+    common HTTP guard/404 behavior in `backend/http/dispatch.py`; and keep endpoint-specific
+    parsing and responses in the corresponding `backend/features/<feature>/routes.py`.
+16. Do not add preservation source-range markers, copied historical CSS fragments, or a tool
+    that reconstructs the retired monolithic frontend. Historical maps remain evidence only;
+    current owners and behavior tests are the maintenance boundary.
+
+Current maintenance rules are in `AGENTS.md` and
+`docs/maintenance/人工维护指南.md`. Historical migration constraints and evidence remain under
+`docs/migration/` for audit only.

app/DOCKER_DEPLOY.md

@@ -44,8 +44,8 @@ docker compose version
 
 ## 3. 迁移现有数据
 
-迁移前先停止当前 Windows 上的 `8765` 服务，避免复制过程中 SQLite 继续写入。
-然后在 `webapp` 目录执行一次 WAL 检查点：
+迁移前先停止当前 Windows 服务，避免复制过程中 SQLite 继续写入。
+然后在应用目录执行一次 WAL 检查点：
 
 ```powershell
 python -c "import sqlite3; c=sqlite3.connect('data/review.db'); print(c.execute('PRAGMA wal_checkpoint(TRUNCATE)').fetchone()); c.close()"
@@ -54,11 +54,11 @@ python -c "import sqlite3; c=sqlite3.connect('data/review.db'); print(c.execute(
 结果第一项应为 `0`。必须迁移以下内容：
 
 ```text
-webapp/data/
-webapp/.env
-webapp/Dockerfile
-webapp/compose.yaml
-webapp/其余程序文件
+data/
+.env
+Dockerfile
+compose.yaml
+其余程序文件
 ```
 
 不要重新生成 `APP_ENCRYPTION_KEY`。部署已有数据库时，目标服务器 `.env` 中的
@@ -67,8 +67,8 @@ webapp/其余程序文件
 可以在项目目录生成迁移包：
 
 ```powershell
-tar --exclude='__pycache__' --exclude='*.log' --exclude='data/cache' -czf xiaobai-review.tar.gz -C webapp .
-scp .\xiaobai-review.tar.gz 用户名@服务器IP:/tmp/
+tar --exclude='__pycache__' --exclude='*.log' --exclude='data/cache' -czf ..\xiaobai-review.tar.gz .
+scp ..\xiaobai-review.tar.gz 用户名@服务器IP:/tmp/
 ```
 
 迁移包包含数据库和密钥，传输完成后应及时删除两端的压缩包。

app/README.md

@@ -2,23 +2,26 @@
 
 一个面向 A 股盘后复盘的本地 Web 工作台。后端使用 Python 访问 Tushare Pro，前端不依赖构建工具。
 
+本目录是经过保真迁移、结构治理和用户人工验收的唯一正式源码，不依赖父目录旧程序或失败版本。
+目录职责见[ARCHITECTURE.md](ARCHITECTURE.md)，产品与维护文档见[docs/README.md](docs/README.md)。
+
 当前包含集合竞价、涨停池、炸板池、跌停板、昨日涨停、涨停表现、市场天梯、板块轮动、题材库、人气热榜、龙虎榜和个人复盘工作区。交易日快照与同步记录保存在本地 SQLite 数据库 `data/review.db`。
 
 集合竞价中心采用盘前生命周期：9:15 前显示预告，9:15–9:25 明确等待最终竞价，9:25–9:30 自动读取并重试最终竞价筛选，9:30 后停止更新并冻结为复盘归档。当前 Tushare 只提供 9:25 最终竞价快照，不将其表述为动态虚拟撮合行情。
 
 第三阶段加入了机构席位、席位别名、个股复权日 K、资金流、自选股、涨停原因修订、个股笔记、每日复盘和历史数据回补。
 
-股票代码在桌面端悬停后会显示分时与日 K 快速预览，默认优先展示日 K；移动端点击代码后从底部打开预览面板。股票详情以及板块、题材、指数详情均可在日 K 与最新分时之间切换。日 K 复用个股详情缓存；分时使用隔离的东方财富分钟图表源和短时内存缓存，只负责展示，不写入主行情、不参与情绪、选股或问天计算。图表源不可用时界面会明确显示“分时不可用”，不会使用日 K 数据模拟分时走势。
+股票代码在桌面端悬停后会显示分时与日 K 快速预览，默认优先展示日 K；移动端点击代码后从底部打开预览面板。股票详情以及板块、题材、指数详情均可在日 K 与最新分时之间切换。日 K 复用个股详情缓存；分时优先使用 iFinD，东方财富仅作隔离的展示兜底，并使用短时内存缓存。图表数据不写入主行情、不参与情绪、选股或问天计算；不可用时明确显示“分时不可用”，不会用日 K 模拟分时走势。
 
-智能选股模块包含 45 日全市场因子库、六阶段市场识别、七套内置策略、受控公式 DSL、自然语言策略编译、候选排名和滚动回测。竞价涨幅、竞价成交额、竞价换手率与竞价量比随因子数据一并同步，可用于自定义公式和历史回测。首次使用需在页面点击“同步因子数据”。未配置 LLM 时使用本地策略模板；配置兼容 API 后自动切换为主模型编译，主模型失败时自动使用辅助模型，两者均支持独立连通性测试。
+智能选股包含六阶段盘后候选、29 套精选策略、自定义公式 DSL、自然语言公式编译、候选排名和滚动回测。阶段与精选策略在当日行情更新后由后台确定性计算；自定义选股由用户手动执行，LLM 只负责编译自然语言条件，不参与候选筛选。竞价、估值、财务、资金、人气和席位等字段按已登记的数据可用性进入因子库，缺失时明确显示覆盖问题。
 
-每次选股结果会自动进入五交易日持续跟踪，展示 T+1 开盘/收盘、T+3、T+5、最大涨幅与最大回撤。提醒中心支持手工日期提醒，并在策略首日反馈和五日跟踪完成时生成账号私有的站内提醒。
+候选只有经用户手动加入后才进入五交易日持续跟踪，展示 T+1 开盘/收盘、T+3、T+5、最大涨幅与最大回撤。提醒中心支持手工日期提醒，并在策略首日反馈和五日跟踪完成时生成账号私有的站内提醒。
 
 问师模块会读取当前复盘、近十日市场情绪、涨跌停、昨日反馈、板块轮动、市场阶段、龙虎榜和指定个股数据，再按选中的游资思维 Skill 进行单师对话。对话记录按账号、老师和交易日期保存在服务端；主模型不可用时自动切换辅助模型。
 
 新增公开问师角色时，在 `游资skills` 下增加一个包含 `SKILL.md` 的独立目录，并在 `游资skills/mentor_catalog.json` 中登记素材等级与结构质检。管理员私有角色放在 `data/private-mentor-skills`，该目录不进入 Git 或 Docker 镜像，且只会出现在管理员的问师列表中。系统会从 Skill 的 frontmatter、一级标题、核心模型和引用语中自动生成角色信息，无需修改注册代码。
 
-问天模块包含三个相互独立的部分：观势以市场数据生成三才六爻，用于观察“势”，行情缺失或自动取象明显偏差时可显式手动校准六爻，人工结果与自动来源严格区分；观气依据干支、精确节气、五运六气及客主加临关系观察“运”，行业五行仅作传统取象归类；观心通过30秒静心、六次三枚铜钱起卦、察念和解卦完成一次不输入问题的问心仪式。卦象、干支、节气与气机关系均由本地确定性程序计算，LLM只负责解释，不参与起卦或改动结果。
+问天模块包含三个相互独立的部分：观势以市场数据生成三才六爻，用于观察“势”，行情缺失或自动取象明显偏差时可显式手动校准六爻，人工结果与自动来源严格区分；观气依据干支、精确节气、五运六气及客主加临关系观察“运”，行业五行仅作传统取象归类；观心先准备1秒，再完成5轮“吸3秒、顿2秒、呼4秒”，随后以六次三枚铜钱起卦、察念和解卦完成一次不输入问题的问心仪式。卦象、干支、节气与气机关系均由本地确定性程序计算，LLM只负责解释，不参与起卦或改动结果。
 
 问天模块使用项目本地的 `lunar-python` 计算历法，并使用 `data/iching_zh.json` 中的固定六十四卦、卦辞和爻辞。第三方授权见 `THIRD_PARTY_NOTICES.md`。
 
@@ -27,13 +30,20 @@
 ## 启动
 
 ```powershell
-cd webapp
+cd app
 python -m pip install -r requirements.txt
 python server.py
 ```
 
 浏览器打开 `http://127.0.0.1:8765`，首次使用先注册账号。首个账号自动成为管理员，后续账号默认为普通用户。主行情不再回退演示数据：盘前、非交易日或临时取数失败时沿用最近真实收盘快照；没有任何真实快照时提示等待管理员完成首次同步。
 
+需要后台启动本地验收端口时，使用`tools/start_local.ps1`。该工具把日志、进程号和Python缓存
+统一写入`runtime/`，不在源码根目录产生运行文件：
+
+```powershell
+powershell -ExecutionPolicy Bypass -File tools/start_local.ps1 -Port 8797
+```
+
 局域网 Docker 部署使用 `Dockerfile` 与 `compose.yaml`，完整的迁移、持久化、
 防火墙、备份和恢复步骤见 [DOCKER_DEPLOY.md](DOCKER_DEPLOY.md)。
 
@@ -55,7 +65,7 @@ Tushare 各接口有独立积分权限。程序优先使用 `limit_list_d` 获
 
 ## 隔离实时聚合验证
 
-`realtime_aggregator.py` 用于验证东方财富、同花顺和选股宝网页数据源。它不写入 SQLite 主行情快照，也不参与情绪评分或智能选股；当 Tushare 实时指数权限不可用时，观势会使用东方财富三大指数和板块外显，并继续使用 Tushare 的板块成分内核与个股数据。
+`backend/data/realtime.py`用于验证东方财富、同花顺和选股宝网页数据源。它不写入 SQLite 主行情快照，也不参与情绪评分或智能选股；当 Tushare 实时指数权限不可用时，观势会使用东方财富三大指数和板块外显，并继续使用 Tushare 的板块成分内核与个股数据。
 
 登录后可调用：
 

app/alert_service.py

@@ -1,3 +0,0 @@
-from backend.features.alerts.service import AlertService
-
-__all__ = ["AlertService"]

app/app_config.py

@@ -1,3 +0,0 @@
-"""Compatibility imports for code that still uses the original configuration module."""
-
-from backend.bootstrap.config import *  # noqa: F401,F403

app/backend/bootstrap/config.py

@@ -9,7 +9,7 @@ from typing import Any
 
 
 APP_DIR = Path(__file__).resolve().parents[2]
-STATIC_DIR = APP_DIR / "static"
+STATIC_DIR = APP_DIR / "frontend"
 DATA_DIR = APP_DIR / "data"
 ENV_FILE = APP_DIR / ".env"
 MENTOR_SKILLS_DIR = APP_DIR / "游资skills"
@@ -71,6 +71,10 @@ def normalize_date(value: str) -> str:
     return parsed.strftime("%Y%m%d")
 
 
+def display_compact_date(value: str) -> str:
+    return f"{value[:4]}-{value[4:6]}-{value[6:8]}" if len(value) == 8 else value
+
+
 def validate_stock_code(value: str) -> str:
     code = value.strip()
     if not re.fullmatch(r"\d{6}", code):

app/backend/bootstrap/container.py

@@ -7,12 +7,12 @@ from collections.abc import Callable
 from backend.data import DataGateway, build_data_gateway
 from backend.database.repositories import RepositoryBundle, build_repository_bundle
 from backend.features.alerts import AlertService
+from backend.features.mentor.agent import MentorSkillRegistry
 from backend.features.review import TradeJournalService
-from backend.features.screener import StrategyTrackingService
+from backend.features.screener.engine import ScreenerEngine
+from backend.features.screener.tracking import StrategyTrackingService
 from backend.jobs import InProcessJobRunner, JobRegistry, SQLiteJobRunRepository
 from database import ReviewDatabase
-from mentor_agent import MentorSkillRegistry
-from screener import ScreenerEngine
 from backend.data.providers.ifind_client import IfindHttpClient
 from backend.data.realtime import WebRealtimeAggregator
 from backend.features.market.charts import MarketChartClient

app/backend/bootstrap/runtime.py

@@ -16,12 +16,13 @@ def main(handler_class: type[Any] | None = None, service: Any | None = None) ->
     parser.add_argument("--port", type=int, default=8765)
     args = parser.parse_args()
     server = ThreadingHTTPServer((args.host, args.port), handler_class)
-    print(f"Xiaobai Review Web is running at http://{args.host}:{args.port}")
-    print("Press Ctrl+C to stop.")
     try:
+        service.start_background_jobs()
+        print(f"Xiaobai Review Web is running at http://{args.host}:{args.port}")
+        print("Press Ctrl+C to stop.")
         server.serve_forever()
     except KeyboardInterrupt:
         pass
     finally:
-        service._background_stop.set()
+        service.stop_background_jobs()
         server.server_close()

app/backend/data/numbers.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+import math
+from typing import Any
+
+
+def finite_number(value: Any, default: float = 0.0) -> float:
+    try:
+        number = float(value)
+        return number if math.isfinite(number) else default
+    except (TypeError, ValueError):
+        return default
+
+
+def non_nan_number(value: Any, default: float = 0.0) -> float:
+    try:
+        number = float(value)
+        return number if number == number else default
+    except (TypeError, ValueError):
+        return default

app/backend/data/providers/tushare_daily.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_helpers import _display_time, _prices_equal
+
+
+class DailyMarketMixin:
+    def resolve_trade_context(self, requested: str) -> tuple[str, str]:
+        requested_rows = self.query(
+            "trade_cal",
+            {"exchange": "SSE", "start_date": requested, "end_date": requested},
+            "cal_date,is_open,pretrade_date",
+        )
+        if not requested_rows:
+            trade_date = requested
+        else:
+            row = requested_rows[0]
+            trade_date = row["cal_date"] if row.get("is_open") == 1 else row.get("pretrade_date", requested)
+
+        resolved_rows = self.query(
+            "trade_cal",
+            {"exchange": "SSE", "start_date": trade_date, "end_date": trade_date},
+            "cal_date,is_open,pretrade_date",
+        )
+        previous = resolved_rows[0].get("pretrade_date") if resolved_rows else ""
+        return trade_date, previous or trade_date
+
+    def _load_daily(self, trade_date: str) -> list[dict[str, Any]]:
+        return self.query(
+            "daily",
+            {"trade_date": trade_date},
+            "ts_code,trade_date,open,high,low,close,pct_chg,amount",
+        )
+
+    def _load_limit_type(self, trade_date: str, limit_type: str) -> list[dict[str, Any]]:
+        fields = (
+            "trade_date,ts_code,industry,name,close,pct_chg,amount,limit_amount,"
+            "float_mv,total_mv,turnover_ratio,fd_amount,first_time,last_time,"
+            "open_times,up_stat,limit_times"
+        )
+        rows = self.query(
+            "limit_list_d",
+            {"trade_date": trade_date, "limit_type": limit_type},
+            fields,
+        )
+        for row in rows:
+            row["limit_type"] = limit_type
+            row["amount_unit"] = "yuan"
+        return rows
+
+    def _load_limit_lists(self, trade_date: str) -> list[dict[str, Any]]:
+        rows: list[dict[str, Any]] = []
+        for limit_type in ("U", "D", "Z"):
+            rows.extend(self._load_limit_type(trade_date, limit_type))
+        return rows
+
+    def _derive_limits(
+        self,
+        trade_date: str,
+        daily: list[dict[str, Any]],
+        price_limits: list[dict[str, Any]] | None = None,
+        basic_rows: list[dict[str, Any]] | None = None,
+        previous_limit_rows: list[dict[str, Any]] | None = None,
+        capital_rows: list[dict[str, Any]] | None = None,
+    ) -> list[dict[str, Any]]:
+        if price_limits is None:
+            price_limits = self.query(
+                "stk_limit",
+                {"trade_date": trade_date},
+                "ts_code,trade_date,up_limit,down_limit",
+            )
+        limit_map = {row["ts_code"]: row for row in price_limits}
+        if basic_rows is None:
+            basic_rows = self.query(
+                "stock_basic",
+                {"list_status": "L"},
+                "ts_code,name,industry",
+            )
+        basic_map = {row["ts_code"]: row for row in basic_rows}
+        previous_limit_map = {
+            str(row.get("ts_code") or ""): row for row in (previous_limit_rows or [])
+        }
+        capital_map = {
+            str(row.get("ts_code") or ""): row for row in (capital_rows or [])
+        }
+
+        result: list[dict[str, Any]] = []
+        for row in daily:
+            bounds = limit_map.get(row.get("ts_code"))
+            if not bounds or row.get("close") is None:
+                continue
+            limit_type = ""
+            if _prices_equal(row["close"], bounds.get("up_limit")):
+                limit_type = "U"
+            elif _prices_equal(row["close"], bounds.get("down_limit")):
+                limit_type = "D"
+            elif _prices_equal(row.get("high"), bounds.get("up_limit")):
+                limit_type = "Z"
+            if not limit_type:
+                continue
+            basic = basic_map.get(row["ts_code"], {})
+            previous_limit = previous_limit_map.get(str(row.get("ts_code") or ""), {})
+            streak = (
+                max(1, int(_number(previous_limit.get("limit_times"), 1)) + 1)
+                if limit_type == "U" and previous_limit
+                else 1
+            )
+            item = {
+                    **row,
+                    "name": basic.get("name", "--"),
+                    "industry": basic.get("industry") or "其他",
+                    "limit_type": limit_type,
+                    "limit_times": streak,
+                    "open_times": 1 if limit_type == "Z" else 0,
+                    "amount_unit": row.get("amount_unit") or "thousand_yuan",
+                }
+            if row.get("amount_unit") == "yuan":
+                capital = capital_map.get(str(row.get("ts_code") or ""), {})
+                if not capital and capital_rows is None:
+                    capital = self._latest_capital(str(row.get("ts_code") or ""), trade_date)
+                float_share = _number(capital.get("float_share"))
+                item["turnover_ratio"] = (
+                    _number(row.get("vol")) / float_share / 100 if float_share else 0
+                )
+                item["turnover_source"] = (
+                    "rt_volume/latest_float_share" if float_share else "unavailable"
+                )
+                item["capital_trade_date"] = str(capital.get("trade_date") or "")
+            result.append(item)
+        return result
+
+    @staticmethod
+    def _normalize_limit(row: dict[str, Any], status: str) -> dict[str, Any]:
+        amount = _number(row.get("amount"))
+        if row.get("amount_unit") == "thousand_yuan":
+            amount_billion = amount / 100000
+        else:
+            amount_billion = amount / 100000000
+        return {
+            "code": str(row.get("ts_code", "")).split(".")[0],
+            "ts_code": row.get("ts_code", ""),
+            "name": row.get("name") or "--",
+            "price": _number(row.get("close")),
+            "change": _number(row.get("pct_chg")),
+            "sector": row.get("industry") or "其他",
+            "reason": row.get("industry") or "待补充",
+            "first_time": _display_time(row.get("first_time")),
+            "last_time": _display_time(row.get("last_time")),
+            "open_times": int(_number(row.get("open_times"))),
+            "streak": max(1, int(_number(row.get("limit_times"), 1))),
+            "turnover_rate": _number(row.get("turnover_ratio")),
+            "turnover_source": row.get("turnover_source") or "provider",
+            "capital_trade_date": row.get("capital_trade_date") or "",
+            "amount_billion": round(amount_billion, 2),
+            "seal_amount_million": round(_number(row.get("fd_amount")) / 10000, 0),
+            "float_mv_billion": round(_number(row.get("float_mv")) / 100000000, 1),
+            "status": status,
+        }

app/backend/data/providers/tushare_dashboard.py

@@ -0,0 +1,644 @@
+from __future__ import annotations
+
+from collections import Counter
+from datetime import datetime, time as dt_time, timedelta
+from typing import Any
+
+from backend.bootstrap.config import display_compact_date as _display_date
+from backend.data.numbers import finite_number as _number
+from backend.features.sentiment.engine import apply_sentiment_to_dashboard
+from backend.data.providers.tushare_helpers import (
+    _realtime_market_status,
+    _trading_session_progress,
+    _value_percentile,
+)
+from backend.data.providers.tushare_transport import TushareError
+
+
+class DashboardMixin:
+    def dashboard(self, requested_date: str) -> dict[str, Any]:
+        trade_date, previous_trade_date = self.resolve_trade_context(requested_date)
+        if self.should_use_realtime(requested_date, trade_date):
+            return self._realtime_dashboard(
+                requested_date,
+                trade_date,
+                previous_trade_date,
+            )
+
+        daily = self._load_daily(trade_date)
+        if (
+            not daily
+            and requested_date == datetime.now().astimezone().strftime("%Y%m%d")
+            and trade_date == requested_date
+            and datetime.now().astimezone().time().replace(tzinfo=None) >= dt_time(9, 15)
+        ):
+            return self._realtime_dashboard(
+                requested_date,
+                trade_date,
+                previous_trade_date,
+            )
+        if not daily:
+            raise TushareError(f"No daily data returned for {trade_date}")
+
+        notices: list[str] = []
+        try:
+            limit_rows = self._load_limit_lists(trade_date)
+            previous_limit_rows = self._load_limit_type(previous_trade_date, "U")
+            if not limit_rows:
+                notices.append("涨跌停高级接口当日数据尚未更新，已使用日线数据推算。")
+                limit_rows = self._derive_limits(trade_date, daily)
+        except TushareError as exc:
+            notices.append(f"涨跌停高级接口不可用，已使用日线数据推算：{exc}")
+            limit_rows = self._derive_limits(trade_date, daily)
+            previous_daily = self._load_daily(previous_trade_date)
+            previous_limit_rows = [
+                row for row in self._derive_limits(previous_trade_date, previous_daily)
+                if row.get("limit_type") == "U"
+            ]
+
+        up_rows = [row for row in limit_rows if row.get("limit_type") == "U"]
+        down_rows = [row for row in limit_rows if row.get("limit_type") == "D"]
+        broken_rows = [row for row in limit_rows if row.get("limit_type") == "Z"]
+        limits = [self._normalize_limit(row, "涨停") for row in up_rows]
+        broken = [self._normalize_limit(row, "炸板") for row in broken_rows]
+        down_limits = [self._normalize_limit(row, "跌停") for row in down_rows]
+        previous_limits = [self._normalize_limit(row, "涨停") for row in previous_limit_rows]
+        yesterday_limits = _build_yesterday_performance(
+            previous_limits,
+            daily,
+            limits,
+            broken,
+            down_limits,
+        )
+        sectors = _build_sectors(limits)
+        previous_sectors = _build_sectors(previous_limits)
+
+        dashboard = {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(trade_date),
+                "previous_trade_date": _display_date(previous_trade_date),
+                "source": "tushare",
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "；".join(notices),
+            },
+            "overview": _build_overview(daily, up_rows, down_rows, broken_rows),
+            "limits": limits,
+            "broken": broken,
+            "down_limits": down_limits,
+            "yesterday_limits": yesterday_limits,
+            "limit_performance": _build_limit_performance(yesterday_limits),
+            "ladders": _build_ladders(limits),
+            "sectors": sectors,
+            "sector_rotation": _build_sector_rotation(sectors, previous_sectors),
+        }
+        return apply_sentiment_to_dashboard(dashboard)
+
+    @staticmethod
+    def should_use_realtime(requested_date: str, trade_date: str) -> bool:
+        """Use rt_k for today's open market until end-of-day datasets settle."""
+        now = datetime.now().astimezone()
+        today = now.strftime("%Y%m%d")
+        return (
+            requested_date == today
+            and trade_date == today
+            and dt_time(9, 15) <= now.time().replace(tzinfo=None) < dt_time(16, 30)
+        )
+
+    def _realtime_dashboard(
+        self,
+        requested_date: str,
+        trade_date: str,
+        previous_trade_date: str,
+    ) -> dict[str, Any]:
+        reference = self._load_realtime_reference(trade_date, previous_trade_date)
+        basic_rows = list(reference["basic_rows"])
+        codes = ",".join(
+            str(row.get("ts_code") or "") for row in basic_rows if row.get("ts_code")
+        )
+        if not codes:
+            raise TushareError("No active stock codes available for rt_k")
+        quotes = self.query("rt_k", {"ts_code": codes})
+        if not quotes:
+            raise TushareError(f"No realtime data returned for {trade_date}")
+
+        basic_map = {str(row.get("ts_code") or ""): row for row in basic_rows}
+        daily: list[dict[str, Any]] = []
+        for quote in quotes:
+            close = _number(quote.get("close"))
+            previous_close = _number(quote.get("pre_close"))
+            if close <= 0 or previous_close <= 0:
+                continue
+            basic = basic_map.get(str(quote.get("ts_code") or ""), {})
+            daily.append(
+                {
+                    **quote,
+                    "trade_date": trade_date,
+                    "name": str(quote.get("name") or basic.get("name") or "--").strip(),
+                    "industry": basic.get("industry") or "其他",
+                    "pct_chg": round((close / previous_close - 1) * 100, 4),
+                    "amount_unit": "yuan",
+                }
+            )
+        with self._realtime_reference_lock:
+            self._latest_realtime_market[trade_date] = {
+                "rows": daily,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+            }
+            if len(self._latest_realtime_market) > 3:
+                oldest = next(iter(self._latest_realtime_market))
+                self._latest_realtime_market.pop(oldest, None)
+
+        limit_rows = self._derive_limits(
+            trade_date,
+            daily,
+            price_limits=list(reference["price_limits"]),
+            basic_rows=basic_rows,
+            previous_limit_rows=list(reference["previous_limit_rows"]),
+            capital_rows=list(reference["capital_rows"]),
+        )
+        previous_limit_rows = list(reference["previous_limit_rows"])
+        up_rows = [row for row in limit_rows if row.get("limit_type") == "U"]
+        down_rows = [row for row in limit_rows if row.get("limit_type") == "D"]
+        broken_rows = [row for row in limit_rows if row.get("limit_type") == "Z"]
+        limits = [self._normalize_limit(row, "涨停") for row in up_rows]
+        broken = [self._normalize_limit(row, "炸板") for row in broken_rows]
+        down_limits = [self._normalize_limit(row, "跌停") for row in down_rows]
+        previous_limits = [self._normalize_limit(row, "涨停") for row in previous_limit_rows]
+        yesterday_limits = _build_yesterday_performance(
+            previous_limits,
+            daily,
+            limits,
+            broken,
+            down_limits,
+        )
+        sectors = _build_sectors(limits)
+        previous_sectors = _build_sectors(previous_limits)
+        now = datetime.now().astimezone()
+        market_status = _realtime_market_status(now.time().replace(tzinfo=None))
+        dashboard = {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(trade_date),
+                "previous_trade_date": _display_date(previous_trade_date),
+                "source": "tushare",
+                "mode": "realtime",
+                "realtime": True,
+                "market_status": market_status,
+                "refresh_mode": "manual",
+                "auto_refresh": False,
+                "quote_count": len(daily),
+                "updated_at": now.isoformat(timespec="seconds"),
+                "notice": "盘中行情由 Tushare rt_k 实时计算；涨停原因、封板时间和开板次数以盘后榜单校正为准。",
+            },
+            "overview": _build_overview(daily, up_rows, down_rows, broken_rows),
+            "limits": limits,
+            "broken": broken,
+            "down_limits": down_limits,
+            "yesterday_limits": yesterday_limits,
+            "limit_performance": _build_limit_performance(yesterday_limits),
+            "ladders": _build_ladders(limits),
+            "sectors": sectors,
+            "sector_rotation": _build_sector_rotation(sectors, previous_sectors),
+        }
+        return apply_sentiment_to_dashboard(dashboard)
+
+    def _load_realtime_reference(
+        self,
+        trade_date: str,
+        previous_trade_date: str,
+    ) -> dict[str, Any]:
+        cache_key = f"{trade_date}:{previous_trade_date}"
+        with self._realtime_reference_lock:
+            cached = self._realtime_reference_cache.get(cache_key)
+        if cached:
+            return cached
+
+        basic_rows = self.query(
+            "stock_basic",
+            {"exchange": "", "list_status": "L"},
+            "ts_code,name,industry,market,list_date",
+        )
+        price_limits = self.query(
+            "stk_limit",
+            {"trade_date": trade_date},
+            "ts_code,trade_date,up_limit,down_limit",
+        )
+        previous_limit_rows = self._load_limit_type(previous_trade_date, "U")
+        capital_rows = self.query(
+            "daily_basic",
+            {"trade_date": previous_trade_date},
+            "ts_code,trade_date,total_share,float_share,free_share,total_mv,circ_mv",
+        )
+        if not basic_rows or not price_limits:
+            raise TushareError(f"Realtime reference data is incomplete for {trade_date}")
+        result = {
+            "basic_rows": basic_rows,
+            "price_limits": price_limits,
+            "previous_limit_rows": previous_limit_rows,
+            "capital_rows": capital_rows,
+        }
+        with self._realtime_reference_lock:
+            self._realtime_reference_cache[cache_key] = result
+            if len(self._realtime_reference_cache) > 3:
+                oldest = next(iter(self._realtime_reference_cache))
+                self._realtime_reference_cache.pop(oldest, None)
+        return result
+
+    def realtime_stock_quote(
+        self,
+        ts_code: str,
+        reference_date: str = "",
+    ) -> dict[str, Any]:
+        rows = self.query("rt_k", {"ts_code": ts_code})
+        if not rows:
+            raise TushareError(f"No realtime quote returned for {ts_code}")
+        row = rows[0]
+        close = _number(row.get("close"))
+        previous_close = _number(row.get("pre_close"))
+        if close <= 0 or previous_close <= 0:
+            raise TushareError(f"Realtime quote is unavailable for {ts_code}")
+
+        basic: dict[str, Any] = {}
+        with self._realtime_reference_lock:
+            references = list(self._realtime_reference_cache.values())
+        for reference in reversed(references):
+            basic = next(
+                (
+                    item for item in reference.get("basic_rows") or []
+                    if str(item.get("ts_code") or "") == ts_code
+                ),
+                {},
+            )
+            if basic:
+                break
+        if not basic:
+            basics = self.query(
+                "stock_basic",
+                {"ts_code": ts_code},
+                "ts_code,name,industry,market,list_date",
+            )
+            basic = basics[0] if basics else {}
+        capital = self._latest_capital(ts_code, reference_date)
+        float_share = _number(capital.get("float_share"))
+        # rt_k volume is shares; daily_basic float_share is reported in 10k shares.
+        turnover_rate = _number(row.get("vol")) / float_share / 100 if float_share else 0
+        market_date = reference_date or datetime.now().astimezone().strftime("%Y%m%d")
+        self._ensure_realtime_market_cache(market_date)
+        with self._realtime_reference_lock:
+            market_rows = list((self._latest_realtime_market.get(market_date) or {}).get("rows") or [])
+            references = list(self._realtime_reference_cache.values())
+        capital_map: dict[str, dict[str, Any]] = {}
+        for reference in reversed(references):
+            capital_map = {
+                str(item.get("ts_code") or ""): item
+                for item in reference.get("capital_rows") or []
+            }
+            if capital_map:
+                break
+        market_amounts = [_number(item.get("amount")) for item in market_rows if _number(item.get("amount")) > 0]
+        amount_percentile = _value_percentile(_number(row.get("amount")), market_amounts)
+        market_turnovers = []
+        for item in market_rows:
+            item_capital = capital_map.get(str(item.get("ts_code") or ""), {})
+            item_float_share = _number(item_capital.get("float_share"))
+            if item_float_share:
+                market_turnovers.append(_number(item.get("vol")) / item_float_share / 100)
+        market_turnover = (
+            sum(market_turnovers) / len(market_turnovers) if market_turnovers else 0
+        )
+        turnover_relative = turnover_rate / market_turnover if market_turnover else 0
+        activity = self._stock_activity_metrics(
+            ts_code,
+            market_date,
+            _number(row.get("vol")) / 100,
+        )
+        return {
+            "code": ts_code.split(".")[0],
+            "ts_code": ts_code,
+            "name": str(row.get("name") or basic.get("name") or "--").strip(),
+            "sector": basic.get("industry") or "其他",
+            "price": round(close, 3),
+            "change": round((close / previous_close - 1) * 100, 4),
+            "open": round(_number(row.get("open")), 3),
+            "high": round(_number(row.get("high")), 3),
+            "low": round(_number(row.get("low")), 3),
+            "previous_close": round(previous_close, 3),
+            "amount_billion": round(_number(row.get("amount")) / 100000000, 3),
+            "volume": _number(row.get("vol")),
+            "trade_count": int(_number(row.get("num"))),
+            "turnover_rate": round(turnover_rate, 4),
+            "market_turnover_rate": round(market_turnover, 4),
+            "turnover_relative": round(turnover_relative, 4),
+            "amount_percentile": round(amount_percentile * 100, 2),
+            "volume_activity_ratio": activity.get("volume_activity_ratio", 0),
+            "activity_history_date": activity.get("history_trade_date", ""),
+            "activity_source": activity.get("source", "unavailable"),
+            "float_share_10k": float_share,
+            "capital_trade_date": str(capital.get("trade_date") or ""),
+            "turnover_source": "rt_volume/latest_float_share" if float_share else "unavailable",
+            "data_source": "tushare",
+            "realtime": True,
+        }
+
+    def _stock_activity_metrics(
+        self,
+        ts_code: str,
+        reference_date: str,
+        current_volume_lots: float,
+    ) -> dict[str, Any]:
+        cache_key = f"{ts_code}:{reference_date}"
+        with self._realtime_reference_lock:
+            history = self._stock_activity_cache.get(cache_key)
+        if history is None:
+            try:
+                end = datetime.strptime(reference_date, "%Y%m%d")
+            except ValueError:
+                end = datetime.now().astimezone().replace(tzinfo=None)
+            rows = self.query(
+                "daily",
+                {
+                    "ts_code": ts_code,
+                    "start_date": (end - timedelta(days=30)).strftime("%Y%m%d"),
+                    "end_date": reference_date,
+                },
+                "ts_code,trade_date,vol,amount",
+            )
+            completed = [
+                item for item in rows
+                if str(item.get("trade_date") or "") < reference_date and _number(item.get("vol")) > 0
+            ]
+            completed.sort(key=lambda item: str(item.get("trade_date") or ""))
+            recent = completed[-5:]
+            history = {
+                "average_volume_lots": (
+                    sum(_number(item.get("vol")) for item in recent) / len(recent)
+                    if recent else 0
+                ),
+                "history_trade_date": str(recent[-1].get("trade_date") or "") if recent else "",
+            }
+            with self._realtime_reference_lock:
+                self._stock_activity_cache[cache_key] = history
+                if len(self._stock_activity_cache) > 256:
+                    oldest = next(iter(self._stock_activity_cache))
+                    self._stock_activity_cache.pop(oldest, None)
+        average_volume = _number(history.get("average_volume_lots"))
+        progress = _trading_session_progress(datetime.now().astimezone().time().replace(tzinfo=None))
+        expected_volume = average_volume * progress
+        ratio = current_volume_lots / expected_volume if expected_volume else 0
+        return {
+            **history,
+            "volume_activity_ratio": round(ratio, 4),
+            "session_progress": round(progress, 4),
+            "source": "rt_volume/5d_average_at_same_progress" if expected_volume else "unavailable",
+        }
+
+    def realtime_factor_snapshot(self, requested_date: str) -> dict[str, Any]:
+        trade_date, previous_trade_date = self.resolve_trade_context(requested_date)
+        reference = self._load_realtime_reference(trade_date, previous_trade_date)
+        codes = [
+            str(row.get("ts_code") or "")
+            for row in reference.get("basic_rows") or []
+            if row.get("ts_code")
+        ]
+        quotes = self.query("rt_k", {"ts_code": ",".join(codes)}, "")
+        capital_map = {
+            str(row.get("ts_code") or ""): row
+            for row in reference.get("capital_rows") or []
+        }
+        rows = []
+        for quote in quotes:
+            ts_code = str(quote.get("ts_code") or "")
+            close = _number(quote.get("close"))
+            previous_close = _number(quote.get("pre_close"))
+            if not ts_code or close <= 0 or previous_close <= 0:
+                continue
+            capital = capital_map.get(ts_code, {})
+            float_share = _number(capital.get("float_share"))
+            rows.append(
+                {
+                    "ts_code": ts_code,
+                    "trade_date": trade_date,
+                    "open": _number(quote.get("open")),
+                    "high": _number(quote.get("high")),
+                    "low": _number(quote.get("low")),
+                    "close": close,
+                    "pct_chg": (close / previous_close - 1) * 100,
+                    "vol": _number(quote.get("vol")) / 100,
+                    "amount": _number(quote.get("amount")),
+                    "turnover_rate": (
+                        _number(quote.get("vol")) / float_share / 100 if float_share else 0
+                    ),
+                    "capital_trade_date": str(capital.get("trade_date") or ""),
+                }
+            )
+        if not rows:
+            raise TushareError(f"No realtime factor snapshot returned for {trade_date}")
+        return {
+            "trade_date": trade_date,
+            "previous_trade_date": previous_trade_date,
+            "source": "tushare_rt_k",
+            "realtime": True,
+            "rows": rows,
+        }
+
+    def _ensure_realtime_market_cache(self, requested_date: str) -> list[dict[str, Any]]:
+        with self._realtime_reference_lock:
+            cached = list(
+                (self._latest_realtime_market.get(requested_date) or {}).get("rows") or []
+            )
+        if cached:
+            return cached
+        trade_date, previous_trade_date = self.resolve_trade_context(requested_date)
+        if trade_date != requested_date:
+            return []
+        reference = self._load_realtime_reference(trade_date, previous_trade_date)
+        codes = [
+            str(row.get("ts_code") or "")
+            for row in reference.get("basic_rows") or []
+            if row.get("ts_code")
+        ]
+        quotes = self.query("rt_k", {"ts_code": ",".join(codes)}, "")
+        rows = [
+            row for row in quotes
+            if _number(row.get("close")) > 0 and _number(row.get("pre_close")) > 0
+        ]
+        with self._realtime_reference_lock:
+            self._latest_realtime_market[trade_date] = {
+                "rows": rows,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+            }
+        return rows
+
+    def _latest_capital(self, ts_code: str, reference_date: str = "") -> dict[str, Any]:
+        end_date = reference_date or datetime.now().astimezone().strftime("%Y%m%d")
+        cache_key = f"{ts_code}:{end_date}"
+        with self._realtime_reference_lock:
+            cached = self._capital_cache.get(cache_key)
+        if cached:
+            return cached
+        try:
+            end = datetime.strptime(end_date, "%Y%m%d")
+        except ValueError:
+            end = datetime.now().astimezone().replace(tzinfo=None)
+            end_date = end.strftime("%Y%m%d")
+        start_date = (end - timedelta(days=20)).strftime("%Y%m%d")
+        rows = self.query(
+            "daily_basic",
+            {"ts_code": ts_code, "start_date": start_date, "end_date": end_date},
+            "ts_code,trade_date,turnover_rate,volume_ratio,total_share,float_share,"
+            "free_share,total_mv,circ_mv",
+        )
+        rows.sort(key=lambda item: str(item.get("trade_date") or ""))
+        result = rows[-1] if rows else {}
+        with self._realtime_reference_lock:
+            self._capital_cache[cache_key] = result
+            if len(self._capital_cache) > 256:
+                oldest = next(iter(self._capital_cache))
+                self._capital_cache.pop(oldest, None)
+        return result
+
+
+def _build_overview(
+    daily: list[dict[str, Any]],
+    up_rows: list[dict[str, Any]],
+    down_rows: list[dict[str, Any]],
+    broken_rows: list[dict[str, Any]],
+) -> dict[str, Any]:
+    up_count = sum(1 for row in daily if _number(row.get("pct_chg")) > 0)
+    down_count = sum(1 for row in daily if _number(row.get("pct_chg")) < 0)
+    flat_count = len(daily) - up_count - down_count
+    amount_billion = sum(
+        _number(row.get("amount"))
+        / (100000000 if row.get("amount_unit") == "yuan" else 100000)
+        for row in daily
+    )
+    limit_count = len(up_rows)
+    broken_count = len(broken_rows)
+    seal_rate = round(limit_count / max(limit_count + broken_count, 1) * 100, 1)
+    return {
+        "up_count": up_count,
+        "down_count": down_count,
+        "flat_count": flat_count,
+        "limit_up_count": limit_count,
+        "limit_down_count": len(down_rows),
+        "broken_count": broken_count,
+        "amount_billion": round(amount_billion, 1),
+        "seal_rate": seal_rate,
+    }
+
+
+def _build_ladders(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    groups: dict[int, list[dict[str, Any]]] = {}
+    for row in rows:
+        groups.setdefault(int(row.get("streak") or 1), []).append(row)
+    return [
+        {
+            "level": level,
+            "label": "首板" if level == 1 else f"{level}板",
+            "count": len(stocks),
+            "stocks": sorted(stocks, key=lambda item: item.get("first_time") or "99:99:99"),
+        }
+        for level, stocks in sorted(groups.items(), reverse=True)
+    ]
+
+
+def _build_sectors(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    counts = Counter(row.get("sector") or "其他" for row in rows)
+    result: list[dict[str, Any]] = []
+    for name, count in counts.most_common(20):
+        stocks = [row for row in rows if (row.get("sector") or "其他") == name]
+        max_streak = max(item.get("streak", 1) for item in stocks)
+        leader = max(stocks, key=lambda item: (item.get("streak", 1), item.get("amount_billion", 0)))
+        result.append(
+            {
+                "name": name,
+                "count": count,
+                "strength": min(100, 44 + count * 8 + max_streak * 5),
+                "amount_billion": round(sum(item.get("amount_billion", 0) for item in stocks), 1),
+                "leader": leader.get("name", "--"),
+                "change": round(sum(item.get("change", 0) for item in stocks) / count, 2),
+                "max_streak": max_streak,
+            }
+        )
+    return result
+
+
+def _build_yesterday_performance(
+    previous_limits: list[dict[str, Any]],
+    daily: list[dict[str, Any]],
+    current_limits: list[dict[str, Any]],
+    current_broken: list[dict[str, Any]],
+    current_down: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    daily_map = {str(row.get("ts_code", "")).split(".")[0]: row for row in daily}
+    limit_map = {row["code"]: row for row in current_limits}
+    broken_codes = {row["code"] for row in current_broken}
+    down_codes = {row["code"] for row in current_down}
+    result = []
+    for previous in previous_limits:
+        code = previous["code"]
+        daily_row = daily_map.get(code, {})
+        current = limit_map.get(code)
+        if current:
+            outcome = "晋级"
+        elif code in broken_codes:
+            outcome = "炸板"
+        elif code in down_codes:
+            outcome = "跌停"
+        else:
+            outcome = "断板"
+        result.append(
+            {
+                "code": code,
+                "name": previous["name"],
+                "prior_streak": previous.get("streak", 1),
+                "current_streak": current.get("streak", 0) if current else 0,
+                "current_change": _number(daily_row.get("pct_chg")),
+                "current_price": _number(daily_row.get("close")),
+                "sector": previous.get("sector", "其他"),
+                "reason": previous.get("reason", "待补充"),
+                "outcome": outcome,
+            }
+        )
+    return result
+
+
+def _build_limit_performance(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    result = []
+    for level in sorted({int(row.get("prior_streak") or 1) for row in rows}, reverse=True):
+        group = [row for row in rows if int(row.get("prior_streak") or 1) == level]
+        advanced = sum(row.get("outcome") == "晋级" for row in group)
+        positive = sum(_number(row.get("current_change")) > 0 for row in group)
+        result.append(
+            {
+                "level": level,
+                "label": "昨日首板" if level == 1 else f"昨日{level}板",
+                "count": len(group),
+                "advanced": advanced,
+                "advance_rate": round(advanced / len(group) * 100, 1),
+                "positive_rate": round(positive / len(group) * 100, 1),
+                "average_change": round(sum(_number(row.get("current_change")) for row in group) / len(group), 2),
+            }
+        )
+    return result
+
+
+def _build_sector_rotation(
+    current: list[dict[str, Any]], previous: list[dict[str, Any]]
+) -> list[dict[str, Any]]:
+    previous_map = {row["name"]: row for row in previous}
+    result = []
+    for index, sector in enumerate(current, start=1):
+        previous_count = int(previous_map.get(sector["name"], {}).get("count", 0))
+        delta = int(sector["count"]) - previous_count
+        result.append(
+            {
+                **sector,
+                "rank": index,
+                "previous_count": previous_count,
+                "delta": delta,
+                "trend": "升温" if delta > 0 else "降温" if delta < 0 else "持平",
+            }
+        )
+    return result

app/backend/data/providers/tushare_dragon_tiger.py

@@ -0,0 +1,214 @@
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime
+from typing import Any
+
+from backend.bootstrap.config import display_compact_date as _display_date
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_helpers import _text
+from backend.data.providers.tushare_transport import TushareError
+
+
+class DragonTigerMixin:
+    def hot_money_profiles(self) -> dict[str, Any]:
+        rows = self.query("hm_list", {}, "name,desc,orgs")
+        profiles: list[dict[str, Any]] = []
+        seen_names: set[str] = set()
+        for row in rows:
+            name = str(row.get("name") or "").strip()
+            if not name or name in seen_names:
+                continue
+            seen_names.add(name)
+            description = _text(row.get("desc"))
+            organization_text = _text(row.get("orgs"))
+            parsed_organizations: Any = None
+            if organization_text.startswith("["):
+                try:
+                    parsed_organizations = json.loads(organization_text)
+                except json.JSONDecodeError:
+                    parsed_organizations = None
+            organization_parts = (
+                parsed_organizations
+                if isinstance(parsed_organizations, list)
+                else re.split(r"[,，;；\n]+", organization_text)
+            )
+            organizations = list(dict.fromkeys(
+                _text(part)
+                for part in organization_parts
+                if _text(part)
+            ))
+            profiles.append(
+                {
+                    "id": f"hot-money-profile-{len(profiles) + 1}",
+                    "name": name,
+                    "description": description,
+                    "organizations": organizations,
+                    "organization_count": len(organizations),
+                }
+            )
+        return {
+            "meta": {
+                "source": "tushare",
+                "status": "success" if profiles else "empty",
+                "schema_version": 1,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "",
+            },
+            "summary": {
+                "profile_count": len(profiles),
+                "described_count": sum(bool(item["description"]) for item in profiles),
+                "organization_count": sum(item["organization_count"] for item in profiles),
+            },
+            "profiles": profiles,
+        }
+
+    def dragon_tiger(self, requested_date: str) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        detail_rows = self.query(
+            "hm_detail",
+            {"trade_date": trade_date},
+            "trade_date,ts_code,ts_name,buy_amount,sell_amount,net_amount,"
+            "hm_name,hm_orgs,tag",
+        )
+
+        notices: list[str] = []
+        try:
+            directory_rows = self.query("hm_list", {}, "name,desc,orgs")
+        except TushareError as exc:
+            directory_rows = []
+            notices.append(f"游资名录暂不可用：{exc}")
+        directory = {
+            str(row.get("name") or "").strip(): {
+                "description": _text(row.get("desc")),
+                "orgs": _text(row.get("orgs")),
+            }
+            for row in directory_rows
+            if str(row.get("name") or "").strip()
+        }
+
+        # 个股龙虎榜仅用于补充涨幅和上榜原因，不参与游资身份识别。
+        try:
+            top_rows = self.query(
+                "top_list",
+                {"trade_date": trade_date},
+                "trade_date,ts_code,name,pct_change,reason",
+            )
+        except TushareError as exc:
+            top_rows = []
+            notices.append(f"个股龙虎榜辅助信息暂不可用：{exc}")
+        stock_context: dict[str, dict[str, Any]] = {}
+        for row in top_rows:
+            ts_code = str(row.get("ts_code") or "")
+            if ts_code and ts_code not in stock_context:
+                stock_context[ts_code] = row
+
+        groups: dict[str, dict[str, Any]] = {}
+        for row in detail_rows:
+            trader_name = str(row.get("hm_name") or "未命名游资").strip()
+            ts_code = str(row.get("ts_code") or "").strip()
+            stock = stock_context.get(ts_code, {})
+            directory_item = directory.get(trader_name, {})
+            seat_name = _text(row.get("hm_orgs")) or directory_item.get("orgs") or "--"
+            buy = round(_number(row.get("buy_amount")) / 1000000, 2)
+            sell = round(_number(row.get("sell_amount")) / 1000000, 2)
+            net_buy = round(_number(row.get("net_amount")) / 1000000, 2)
+            group = groups.setdefault(
+                trader_name,
+                {
+                    "name": trader_name,
+                    "description": directory_item.get("description") or "",
+                    "directory_orgs": directory_item.get("orgs") or "",
+                    "identity_type": "trader",
+                    "identity_source": "tushare_hm",
+                    "recognized": True,
+                    "buy_million": 0.0,
+                    "sell_million": 0.0,
+                    "net_buy_million": 0.0,
+                    "seat_names": set(),
+                    "stock_codes": set(),
+                    "operations": [],
+                },
+            )
+            group["buy_million"] += buy
+            group["sell_million"] += sell
+            group["net_buy_million"] += net_buy
+            if seat_name != "--":
+                group["seat_names"].add(seat_name)
+            code = ts_code.split(".")[0]
+            if code:
+                group["stock_codes"].add(code)
+            group["operations"].append(
+                {
+                    "code": code,
+                    "ts_code": ts_code,
+                    "name": row.get("ts_name") or stock.get("name") or "--",
+                    "change": (
+                        _number(stock.get("pct_change"))
+                        if stock.get("pct_change") is not None
+                        else None
+                    ),
+                    "direction": "买入" if net_buy > 0 else "卖出" if net_buy < 0 else "持平",
+                    "buy_million": buy,
+                    "sell_million": sell,
+                    "net_buy_million": net_buy,
+                    "seat_name": seat_name,
+                    "seat_alias": trader_name,
+                    "tag": _text(row.get("tag")) or "--",
+                    "reason": _text(stock.get("reason")) or "--",
+                }
+            )
+
+        traders = list(groups.values())
+        traders.sort(key=lambda item: abs(item["net_buy_million"]), reverse=True)
+        for index, group in enumerate(traders, start=1):
+            group["id"] = f"hot-money-{index}"
+            group["buy_million"] = round(group["buy_million"], 2)
+            group["sell_million"] = round(group["sell_million"], 2)
+            group["net_buy_million"] = round(group["net_buy_million"], 2)
+            group["seat_count"] = len(group.pop("seat_names"))
+            group["stock_count"] = len(group.pop("stock_codes"))
+            group["operation_count"] = len(group["operations"])
+            group["operations"].sort(
+                key=lambda item: abs(float(item.get("net_buy_million") or 0)), reverse=True
+            )
+
+        operation_count = sum(item["operation_count"] for item in traders)
+        active_stocks = {
+            operation["code"] for item in traders for operation in item["operations"]
+            if operation["code"]
+        }
+        net_buy_total = round(sum(item["net_buy_million"] for item in traders), 2)
+        status = "success" if detail_rows else "partial" if top_rows else "empty"
+        if not detail_rows:
+            notices.insert(
+                0,
+                f"当日有 {len(stock_context)} 只股票上榜，但未返回可识别的游资每日明细。"
+                if top_rows
+                else "该交易日未返回龙虎榜或游资每日明细。",
+            )
+        return {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(trade_date),
+                "source": "tushare",
+                "status": status,
+                "schema_version": 3,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "；".join(notices),
+            },
+            "summary": {
+                "trader_count": len(traders),
+                "identity_count": len(traders),
+                "operation_count": operation_count,
+                "active_stock_count": len(active_stocks),
+                "seat_net_buy_million": net_buy_total,
+                "unclassified_count": 0,
+                "directory_count": len(directory),
+                "official_stock_count": len(stock_context),
+            },
+            "traders": traders,
+            "unclassified_seats": [],
+            "rows": [],
+        }

app/backend/data/providers/tushare_helpers.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from datetime import time as dt_time
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+
+
+def _text(value: Any) -> str:
+    if isinstance(value, (list, tuple, set)):
+        return "、".join(str(item).strip() for item in value if str(item).strip())
+    return str(value or "").strip()
+
+
+def _prices_equal(left: Any, right: Any) -> bool:
+    if left is None or right is None:
+        return False
+    return abs(_number(left) - _number(right)) < 0.005
+
+
+def _value_percentile(value: float, population: list[float]) -> float:
+    valid = sorted(item for item in population if item >= 0)
+    if not valid:
+        return 0.0
+    below = sum(item < value for item in valid)
+    equal = sum(item == value for item in valid)
+    return (below + equal * 0.5) / len(valid)
+
+
+def _trading_session_progress(current_time: dt_time) -> float:
+    morning_start = dt_time(9, 30)
+    morning_end = dt_time(11, 30)
+    afternoon_start = dt_time(13, 0)
+    afternoon_end = dt_time(15, 0)
+    if current_time <= morning_start:
+        return 0.05
+    if current_time <= morning_end:
+        minutes = (current_time.hour * 60 + current_time.minute) - (9 * 60 + 30)
+        return max(0.05, min(0.5, minutes / 240))
+    if current_time < afternoon_start:
+        return 0.5
+    if current_time <= afternoon_end:
+        minutes = (current_time.hour * 60 + current_time.minute) - 13 * 60
+        return max(0.5, min(1.0, 0.5 + minutes / 240))
+    return 1.0
+
+
+def _display_time(value: Any) -> str:
+    raw = str(value or "").replace(":", "").zfill(6)
+    if not raw.strip("0"):
+        return "--"
+    return f"{raw[:2]}:{raw[2:4]}:{raw[4:6]}"
+
+
+def _realtime_market_status(current_time: dt_time) -> str:
+    if current_time < dt_time(9, 25):
+        return "pre_open"
+    if current_time < dt_time(9, 30):
+        return "auction"
+    if current_time <= dt_time(11, 30) or dt_time(13, 0) <= current_time <= dt_time(15, 0):
+        return "trading"
+    if current_time < dt_time(13, 0):
+        return "lunch_break"
+    return "closed"

app/backend/data/providers/tushare_indices.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_transport import TushareError
+
+
+class IndexMixin:
+    def market_indices(self, requested_date: str, lookback_days: int = 45) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        end = datetime.strptime(trade_date, "%Y%m%d")
+        start_date = (end - timedelta(days=max(30, lookback_days * 2))).strftime("%Y%m%d")
+        index_names = {
+            "000001.SH": "上证指数",
+            "399001.SZ": "深证成指",
+            "399006.SZ": "创业板指",
+        }
+        indices = []
+        for ts_code, name in index_names.items():
+            rows = self.query(
+                "index_daily",
+                {"ts_code": ts_code, "start_date": start_date, "end_date": trade_date},
+                "ts_code,trade_date,close,pct_chg,vol,amount",
+            )
+            rows.sort(key=lambda item: str(item.get("trade_date") or ""))
+            if not rows:
+                continue
+            latest = rows[-1]
+            close = _number(latest.get("close"))
+            close_5d = _number(rows[-6].get("close")) if len(rows) >= 6 else _number(rows[0].get("close"))
+            close_20d = _number(rows[-21].get("close")) if len(rows) >= 21 else _number(rows[0].get("close"))
+            indices.append(
+                {
+                    "ts_code": ts_code,
+                    "name": name,
+                    "trade_date": str(latest.get("trade_date") or trade_date),
+                    "close": close,
+                    "pct_chg": round(_number(latest.get("pct_chg")), 3),
+                    "return_5d": round((close / close_5d - 1) * 100, 3) if close_5d else 0,
+                    "return_20d": round((close / close_20d - 1) * 100, 3) if close_20d else 0,
+                    "amount_billion": round(_number(latest.get("amount")) / 100000, 2),
+                }
+            )
+        if not indices:
+            raise TushareError(f"No index data returned for {trade_date}")
+        return {
+            "trade_date": trade_date,
+            "source": "tushare",
+            "realtime": False,
+            "precise": all(item["trade_date"] == trade_date for item in indices),
+            "indices": indices,
+            "aggregate": {
+                "average_pct_chg": round(sum(item["pct_chg"] for item in indices) / len(indices), 3),
+                "average_return_5d": round(sum(item["return_5d"] for item in indices) / len(indices), 3),
+                "average_return_20d": round(sum(item["return_20d"] for item in indices) / len(indices), 3),
+            },
+        }
+
+    def realtime_market_indices(self, requested_date: str) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        index_names = {
+            "000001.SH": "上证指数",
+            "399001.SZ": "深证成指",
+            "399006.SZ": "创业板指",
+        }
+        rows = self.query("rt_idx_k", {"ts_code": ",".join(index_names)}, "")
+        row_map = {str(row.get("ts_code") or ""): row for row in rows}
+        indices = []
+        for ts_code, name in index_names.items():
+            row = row_map.get(ts_code)
+            if not row:
+                continue
+            close = _number(row.get("close"))
+            previous_close = _number(row.get("pre_close"))
+            if close <= 0 or previous_close <= 0:
+                continue
+            history = self.query(
+                "index_daily",
+                {
+                    "ts_code": ts_code,
+                    "start_date": (datetime.strptime(trade_date, "%Y%m%d") - timedelta(days=20)).strftime("%Y%m%d"),
+                    "end_date": trade_date,
+                },
+                "ts_code,trade_date,close,pct_chg",
+            )
+            history.sort(key=lambda item: str(item.get("trade_date") or ""))
+            previous_closes = [
+                _number(item.get("close")) for item in history
+                if str(item.get("trade_date") or "") < trade_date and _number(item.get("close")) > 0
+            ]
+            close_5d = previous_closes[-5] if len(previous_closes) >= 5 else previous_closes[0] if previous_closes else previous_close
+            indices.append(
+                {
+                    "ts_code": ts_code,
+                    "name": str(row.get("name") or name).strip(),
+                    "trade_date": trade_date,
+                    "close": close,
+                    "pct_chg": round((close / previous_close - 1) * 100, 3),
+                    "return_5d": round((close / close_5d - 1) * 100, 3) if close_5d else 0,
+                    "amount_billion": round(_number(row.get("amount")) / 100000000, 2),
+                }
+            )
+        if len(indices) != len(index_names):
+            raise TushareError("Realtime index quotes are incomplete")
+        return {
+            "trade_date": trade_date,
+            "source": "tushare_rt_idx_k",
+            "realtime": True,
+            "precise": True,
+            "indices": indices,
+            "aggregate": {
+                "average_pct_chg": round(sum(item["pct_chg"] for item in indices) / len(indices), 3),
+                "average_return_5d": round(sum(item["return_5d"] for item in indices) / len(indices), 3),
+                "average_return_20d": 0,
+            },
+        }

app/backend/data/providers/tushare_industries.py

@@ -0,0 +1,616 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_transport import TushareError
+
+
+class ShenwanIndustryMixin:
+    def sw_stock_industry(self, ts_code: str, trade_date: str) -> dict[str, Any]:
+        """Return the Shenwan industry active for a stock on trade_date."""
+        rows = []
+        for is_new in ("Y", "N"):
+            rows.extend(
+                self.query(
+                    "index_member_all",
+                    {"ts_code": ts_code, "is_new": is_new},
+                    "l1_code,l1_name,l2_code,l2_name,l3_code,l3_name,"
+                    "ts_code,name,in_date,out_date,is_new",
+                )
+            )
+        rows = _reconcile_membership_rows(rows)
+        matched = [row for row in rows if _membership_active_on(row, trade_date)]
+        if not matched:
+            matched = [
+                row for row in rows
+                if row.get("is_new") == "Y"
+                and str(row.get("in_date") or "") <= trade_date
+            ]
+        if not matched:
+            raise TushareError(f"No Shenwan industry returned for {ts_code}")
+        row = max(
+            matched,
+            key=lambda item: (
+                str(item.get("in_date") or ""),
+                1 if item.get("is_new") == "Y" else 0,
+                str(item.get("l3_code") or item.get("l2_code") or ""),
+            ),
+        )
+        return {
+            "l1_code": str(row.get("l1_code") or ""),
+            "l1_name": str(row.get("l1_name") or ""),
+            "l2_code": str(row.get("l2_code") or ""),
+            "l2_name": str(row.get("l2_name") or ""),
+            "l3_code": str(row.get("l3_code") or ""),
+            "l3_name": str(row.get("l3_name") or ""),
+            "in_date": str(row.get("in_date") or ""),
+            "out_date": str(row.get("out_date") or ""),
+            "is_new": str(row.get("is_new") or ""),
+        }
+
+    def sw_sector_snapshot(
+        self,
+        ts_code: str,
+        requested_date: str,
+        realtime_expected: bool = False,
+        allow_realtime_close: bool = False,
+    ) -> dict[str, Any]:
+        """Build the single Shenwan L2 sector context used by heaven trend."""
+        trade_date, previous_trade_date = self.resolve_trade_context(requested_date)
+        industry = self.sw_stock_industry(ts_code, trade_date)
+        sector_code = str(industry.get("l2_code") or "")
+        if not sector_code:
+            raise TushareError(f"Shenwan L2 code is unavailable for {ts_code}")
+        members = self._sw_sector_members(sector_code, trade_date)
+        if not members:
+            raise TushareError(f"No Shenwan members returned for {sector_code}")
+        raw_member_count = len(members)
+        members, excluded_members = _filter_members_by_listing(
+            members,
+            self._stock_listing_reference(),
+            trade_date,
+        )
+        if not members:
+            raise TushareError(f"No listed Shenwan members returned for {sector_code}")
+
+        if realtime_expected:
+            snapshot = self._sw_realtime_sector_snapshot(
+                industry,
+                members,
+                trade_date,
+                previous_trade_date,
+                finalized=False,
+            )
+            snapshot.update({
+                "raw_member_count": raw_member_count,
+                "excluded_member_count": len(excluded_members),
+                "excluded_members": excluded_members,
+            })
+            return snapshot
+
+        member_set = {str(item.get("ts_code") or "") for item in members}
+        member_names = {
+            str(item.get("ts_code") or ""): str(item.get("name") or "")
+            for item in members
+        }
+        member_rows = [
+            row for row in self._load_daily(trade_date)
+            if str(row.get("ts_code") or "") in member_set
+        ]
+        quoted_codes = {str(row.get("ts_code") or "") for row in member_rows}
+        suspended_members = self._confirmed_suspended_members(
+            members, quoted_codes, trade_date
+        )
+        up_count = sum(_number(row.get("pct_chg")) > 0 for row in member_rows)
+        down_count = sum(_number(row.get("pct_chg")) < 0 for row in member_rows)
+        leader = max(member_rows, key=lambda row: _number(row.get("pct_chg")), default={})
+        leader_code = str(leader.get("ts_code") or "")
+        equal_change = (
+            sum(_number(row.get("pct_chg")) for row in member_rows) / len(member_rows)
+            if member_rows else 0
+        )
+        coverage = len(member_rows) / max(len(members), 1) * 100
+        explained_count = len(member_rows) + len(suspended_members)
+        explained_coverage = explained_count / max(len(members), 1) * 100
+        coverage_issue = _sector_coverage_issue(
+            len(members),
+            len(member_rows),
+            explained_coverage,
+            explained_count,
+        )
+        inner_precise = not coverage_issue
+        inner_error = coverage_issue
+        amount_billion = sum(_number(row.get("amount")) for row in member_rows) / 100000
+        rows = self.query(
+            "sw_daily",
+            {"ts_code": sector_code, "trade_date": trade_date},
+            "ts_code,trade_date,name,close,pct_change,vol,amount,pe,pb,float_mv,total_mv",
+        )
+        daily = rows[0] if rows else {}
+        actual_trade_date = str(daily.get("trade_date") or "")
+        outer_precise = actual_trade_date == trade_date
+        outer_error = "" if outer_precise else (
+            f"No Shenwan daily returned for {sector_code} on {trade_date}"
+        )
+        if not outer_precise and allow_realtime_close:
+            try:
+                return self._sw_realtime_sector_snapshot(
+                    industry,
+                    members,
+                    trade_date,
+                    previous_trade_date,
+                    finalized=True,
+                )
+            except TushareError as exc:
+                outer_error = f"{outer_error}; realtime close fallback failed: {exc}"
+
+        official_change = _number(daily.get("pct_change")) if outer_precise else None
+        return {
+            "code": sector_code,
+            "name": industry.get("l2_name") or daily.get("name") or sector_code,
+            "leader": str(leader.get("name") or member_names.get(leader_code) or "--"),
+            "leader_code": leader_code,
+            "leading_pct": round(_number(leader.get("pct_chg")), 3),
+            "change": round(official_change, 3) if official_change is not None else None,
+            "member_equal_change": round(equal_change, 3),
+            "turnover_rate": 0,
+            "up_count": up_count,
+            "down_count": down_count,
+            "flat_count": len(member_rows) - up_count - down_count,
+            "member_count": len(members),
+            "raw_member_count": raw_member_count,
+            "excluded_member_count": len(excluded_members),
+            "excluded_members": excluded_members,
+            "quote_count": len(member_rows),
+            "coverage": round(coverage, 1),
+            "explained_count": explained_count,
+            "explained_coverage": round(explained_coverage, 1),
+            "suspended_count": len(suspended_members),
+            "suspended_members": suspended_members,
+            "strength": round(max(0, min(100, 50 + (official_change if official_change is not None else equal_change) * 5)), 1),
+            "amount_billion": round(amount_billion, 2),
+            "count": 0,
+            "max_streak": 0,
+            "source": "tushare_sw_daily+member_daily" if outer_precise else "tushare_member_daily",
+            "inner_source": "tushare_member_daily",
+            "outer_source": "tushare_sw_daily" if outer_precise else "unavailable",
+            "taxonomy": "sw_l2",
+            "industry": industry,
+            "trade_date": trade_date,
+            "inner_trade_date": trade_date if member_rows else "",
+            "outer_trade_date": actual_trade_date,
+            "realtime": False,
+            "finalized": True,
+            "inner_precise": inner_precise,
+            "outer_precise": outer_precise,
+            "precise": inner_precise and outer_precise,
+            "inner_error": inner_error,
+            "outer_error": outer_error,
+            "schema_version": 6,
+            "methodology": "外显使用申万二级行业官方日线；内核独立使用当日成分日线宽度与等权涨跌聚合",
+        }
+
+    def _sw_sector_members(
+        self,
+        sector_code: str,
+        trade_date: str,
+    ) -> list[dict[str, Any]]:
+        rows = []
+        for is_new in ("Y", "N"):
+            rows.extend(
+                self.query(
+                    "index_member_all",
+                    {"l2_code": sector_code, "is_new": is_new},
+                    "l2_code,l2_name,ts_code,name,in_date,out_date,is_new",
+                )
+            )
+        deduped: dict[str, dict[str, Any]] = {}
+        for row in _reconcile_membership_rows(rows):
+            code = str(row.get("ts_code") or "")
+            if code and _membership_active_on(row, trade_date):
+                current = deduped.get(code)
+                if current is None or str(row.get("in_date") or "") > str(current.get("in_date") or ""):
+                    deduped[code] = row
+        return list(deduped.values())
+
+    def sw_sector_members(self, sector_code: str, trade_date: str) -> list[dict[str, Any]]:
+        """Return constituents active in a Shenwan L2 industry on the target date."""
+        return self._sw_sector_members(sector_code, trade_date)
+
+    def _stock_listing_reference(self) -> dict[str, dict[str, Any]]:
+        now = datetime.now().astimezone()
+        with self._stock_listing_lock:
+            loaded_at = self._stock_listing_cache.get("loaded_at")
+            cached = self._stock_listing_cache.get("rows")
+            if (
+                isinstance(loaded_at, datetime)
+                and isinstance(cached, dict)
+                and now - loaded_at < timedelta(hours=6)
+            ):
+                return cached
+
+        rows: list[dict[str, Any]] = []
+        try:
+            for status in ("L", "D", "P"):
+                rows.extend(self.query(
+                    "stock_basic",
+                    {"list_status": status},
+                    "ts_code,name,list_status,list_date,delist_date",
+                ))
+        except TushareError:
+            # Unknown status must remain in the denominator so a reference-data
+            # failure cannot silently improve coverage.
+            return {}
+        reference = {
+            str(row.get("ts_code") or ""): dict(row)
+            for row in rows
+            if row.get("ts_code")
+        }
+        with self._stock_listing_lock:
+            type(self)._stock_listing_cache = {"loaded_at": now, "rows": reference}
+        return reference
+
+    def _confirmed_suspended_members(
+        self,
+        members: list[dict[str, Any]],
+        quoted_codes: set[str],
+        trade_date: str,
+    ) -> list[dict[str, str]]:
+        suspended: list[dict[str, str]] = []
+        for member in members:
+            code = str(member.get("ts_code") or "")
+            if not code or code in quoted_codes:
+                continue
+            cache_key = f"{trade_date}:{code}"
+            with self._suspension_lock:
+                cached = self._suspension_cache.get(cache_key, "missing")
+            if cached == "missing":
+                try:
+                    rows = self.query(
+                        "suspend_d",
+                        {"ts_code": code},
+                        "ts_code,suspend_date,resume_date,ann_date,suspend_reason,reason_type",
+                    )
+                except TushareError:
+                    rows = []
+                active = [
+                    row for row in rows
+                    if str(row.get("suspend_date") or "")
+                    and str(row.get("suspend_date") or "") <= trade_date
+                    and (
+                        not str(row.get("resume_date") or "")
+                        or trade_date < str(row.get("resume_date") or "")
+                    )
+                ]
+                row = max(
+                    active,
+                    key=lambda item: str(item.get("suspend_date") or ""),
+                    default=None,
+                )
+                cached = ({
+                    "ts_code": code,
+                    "name": str(member.get("name") or code),
+                    "suspend_date": str(row.get("suspend_date") or ""),
+                    "resume_date": str(row.get("resume_date") or ""),
+                    "reason": str(row.get("suspend_reason") or row.get("reason_type") or "已确认停牌"),
+                } if row else None)
+                with self._suspension_lock:
+                    type(self)._suspension_cache[cache_key] = cached
+            if isinstance(cached, dict):
+                suspended.append(cached)
+        return suspended
+
+    def _sw_realtime_sector_snapshot(
+        self,
+        industry: dict[str, Any],
+        members: list[dict[str, Any]],
+        trade_date: str,
+        previous_trade_date: str,
+        finalized: bool = False,
+    ) -> dict[str, Any]:
+        sector_code = str(industry.get("l2_code") or "")
+        sw_rows = self.query(
+            "rt_sw_k",
+            {"ts_code": sector_code},
+            "ts_code,name,trade_time,close,pre_close,high,open,low,vol,amount,pct_change",
+        )
+        sw_row = sw_rows[0] if sw_rows else {}
+        trade_time = str(sw_row.get("trade_time") or "")
+        quote_date = trade_time[:10].replace("-", "")
+        quote_clock = trade_time[11:19] if len(trade_time) >= 19 else ""
+        outer_precise = bool(sw_row and quote_date == trade_date)
+        if finalized and (not quote_clock or quote_clock < "15:00:00"):
+            outer_precise = False
+        official_change = _number(sw_row.get("pct_change"))
+        if not official_change:
+            close = _number(sw_row.get("close"))
+            pre_close = _number(sw_row.get("pre_close"))
+            official_change = (close / pre_close - 1) * 100 if close and pre_close else 0
+        if not outer_precise:
+            official_change = None
+        outer_error = ""
+        if not sw_row:
+            outer_error = f"No Shenwan realtime index returned for {sector_code}"
+        elif quote_date != trade_date:
+            outer_error = f"Shenwan realtime index date is {quote_date or 'unknown'}, expected {trade_date}"
+        elif finalized and (not quote_clock or quote_clock < "15:00:00"):
+            outer_error = f"Shenwan realtime index is not a close snapshot ({trade_time})"
+
+        valid: list[dict[str, Any]] = []
+        codes: list[str] = []
+        reference: dict[str, Any] = {}
+        inner_error = ""
+        try:
+            reference = self._load_realtime_reference(trade_date, previous_trade_date)
+            active_codes = {
+                str(row.get("ts_code") or "")
+                for row in reference.get("basic_rows") or []
+                if row.get("ts_code")
+            }
+            codes = [
+                str(row.get("ts_code") or "")
+                for row in members
+                if str(row.get("ts_code") or "") in active_codes
+            ]
+            if codes:
+                quotes = self.query("rt_k", {"ts_code": ",".join(codes)}, "")
+                for row in quotes:
+                    close = _number(row.get("close"))
+                    previous_close = _number(row.get("pre_close"))
+                    if close <= 0 or previous_close <= 0:
+                        continue
+                    valid.append({**row, "change": (close / previous_close - 1) * 100})
+            else:
+                inner_error = f"No active Shenwan members returned for {sector_code}"
+        except TushareError as exc:
+            inner_error = str(exc)
+
+        coverage = len(valid) / max(len(codes), 1) * 100
+        valid_codes = {str(item.get("ts_code") or "") for item in valid}
+        suspended_members = self._confirmed_suspended_members(
+            members, valid_codes, trade_date
+        )
+        explained_count = len(valid) + len(suspended_members)
+        explained_coverage = explained_count / max(len(codes), 1) * 100
+        coverage_issue = _sector_coverage_issue(
+            len(codes), len(valid), explained_coverage, explained_count
+        )
+        inner_precise = bool(codes) and not coverage_issue
+        if not inner_precise and not inner_error:
+            inner_error = coverage_issue or "申万实时有效成分为空"
+        up_count = sum(item["change"] > 0 for item in valid)
+        down_count = sum(item["change"] < 0 for item in valid)
+        leader = max(valid, key=lambda item: item["change"], default={})
+        leader_code = str(leader.get("ts_code") or "")
+        member_names = {
+            str(item.get("ts_code") or ""): str(item.get("name") or "")
+            for item in members
+        }
+        equal_change = sum(item["change"] for item in valid) / len(valid) if valid else 0
+        amount_billion = sum(_number(item.get("amount")) for item in valid) / 100000000
+        try:
+            self._ensure_realtime_market_cache(trade_date)
+            with self._realtime_reference_lock:
+                market_rows = list(
+                    (self._latest_realtime_market.get(trade_date) or {}).get("rows") or []
+                )
+        except TushareError as exc:
+            market_rows = []
+            inner_precise = False
+            inner_error = inner_error or str(exc)
+        capital_map = {
+            str(item.get("ts_code") or ""): item
+            for item in reference.get("capital_rows") or []
+        }
+        sector_turnovers = []
+        for item in valid:
+            capital = capital_map.get(str(item.get("ts_code") or ""), {})
+            float_share = _number(capital.get("float_share"))
+            if float_share:
+                sector_turnovers.append(_number(item.get("vol")) / float_share / 100)
+        market_turnovers = []
+        for item in market_rows:
+            capital = capital_map.get(str(item.get("ts_code") or ""), {})
+            float_share = _number(capital.get("float_share"))
+            if float_share:
+                market_turnovers.append(_number(item.get("vol")) / float_share / 100)
+        average_turnover = sum(sector_turnovers) / len(sector_turnovers) if sector_turnovers else 0
+        market_turnover = sum(market_turnovers) / len(market_turnovers) if market_turnovers else 0
+        relative_turnover = average_turnover / market_turnover if market_turnover else 0
+        if not relative_turnover:
+            inner_precise = False
+            inner_error = inner_error or "Shenwan member relative turnover is unavailable"
+        return {
+            "code": sector_code,
+            "name": str(industry.get("l2_name") or sw_row.get("name") or ""),
+            "leader": str(leader.get("name") or member_names.get(leader_code) or "--").strip(),
+            "leader_code": leader_code,
+            "leading_pct": round(_number(leader.get("change")), 3),
+            "change": round(official_change, 3) if official_change is not None else None,
+            "member_equal_change": round(equal_change, 3),
+            "turnover_rate": round(average_turnover, 4),
+            "market_turnover_rate": round(market_turnover, 4),
+            "relative_turnover": round(relative_turnover, 4),
+            "up_count": up_count,
+            "down_count": down_count,
+            "flat_count": len(valid) - up_count - down_count,
+            "member_count": len(codes),
+            "quote_count": len(valid),
+            "coverage": round(coverage, 1),
+            "explained_count": explained_count,
+            "explained_coverage": round(explained_coverage, 1),
+            "suspended_count": len(suspended_members),
+            "suspended_members": suspended_members,
+            "strength": round(max(0, min(100, 50 + (official_change if official_change is not None else equal_change) * 5)), 1),
+            "amount_billion": round(amount_billion, 2),
+            "count": sum(item["change"] >= 9.5 for item in valid),
+            "max_streak": 0,
+            "source": "tushare_rt_sw_k+sw_members_rt_k",
+            "inner_source": "tushare_sw_members+rt_k",
+            "outer_source": "tushare_rt_sw_k",
+            "taxonomy": "sw_l2",
+            "industry": industry,
+            "trade_date": trade_date,
+            "inner_trade_date": trade_date if valid else "",
+            "outer_trade_date": quote_date,
+            "trade_time": trade_time,
+            "realtime": True,
+            "finalized": finalized,
+            "inner_precise": inner_precise,
+            "outer_precise": outer_precise,
+            "precise": inner_precise and outer_precise,
+            "inner_error": inner_error,
+            "outer_error": outer_error,
+            "schema_version": 6,
+            "methodology": "外显使用申万官方 rt_sw_k；内核独立使用申万成分 rt_k 宽度与相对换手聚合",
+        }
+
+
+def _filter_members_by_listing(
+    members: list[dict[str, Any]],
+    listing_reference: dict[str, dict[str, Any]],
+    trade_date: str,
+) -> tuple[list[dict[str, Any]], list[dict[str, str]]]:
+    eligible: list[dict[str, Any]] = []
+    excluded: list[dict[str, str]] = []
+    for member in members:
+        code = str(member.get("ts_code") or "")
+        listing = listing_reference.get(code)
+        if not listing:
+            eligible.append(member)
+            continue
+        list_date = str(listing.get("list_date") or "")
+        delist_date = str(listing.get("delist_date") or "")
+        reason = ""
+        effective_date = ""
+        if delist_date and delist_date <= trade_date:
+            reason = "目标日期前已退市"
+            effective_date = delist_date
+        elif list_date and list_date > trade_date:
+            reason = "目标日期尚未上市"
+            effective_date = list_date
+        if not reason:
+            eligible.append(member)
+            continue
+        excluded.append({
+            "ts_code": code,
+            "name": str(member.get("name") or listing.get("name") or code),
+            "reason": reason,
+            "effective_date": effective_date,
+        })
+    return eligible, excluded
+
+
+def _sector_coverage_issue(
+    member_count: int,
+    quote_count: int,
+    coverage: float | None = None,
+    explained_count: int | None = None,
+) -> str:
+    members = max(0, int(member_count or 0))
+    quotes = max(0, min(int(quote_count or 0), members))
+    if members <= 0:
+        if coverage is not None and float(coverage) >= 90:
+            return ""
+        if coverage is not None:
+            return "行业成分行情覆盖率低于90%"
+        return "申万有效成分为空"
+    explained = quotes if explained_count is None else max(
+        quotes, min(int(explained_count or 0), members)
+    )
+    actual_coverage = (
+        float(coverage)
+        if coverage is not None
+        else explained / members * 100
+    )
+    missing = members - explained
+    if members <= 7 and missing:
+        return f"小型行业有效成分状态仅确认 {explained}/{members}，要求全部可解释"
+    if members <= 20 and (actual_coverage < 90 or missing > 1):
+        return f"中型行业有效成分状态仅确认 {explained}/{members}，要求覆盖率至少90%且最多缺1只"
+    if members > 20 and actual_coverage < 90:
+        return f"行业有效成分状态仅确认 {explained}/{members}，覆盖率低于90%"
+    return ""
+
+
+def _membership_active_on(row: dict[str, Any], trade_date: str) -> bool:
+    start = str(row.get("in_date") or "")
+    end = str(row.get("out_date") or "")
+    return (not start or start <= trade_date) and (not end or end > trade_date)
+
+
+def _reconcile_membership_rows(rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    """Merge duplicate Y/N membership rows before evaluating their date interval."""
+    reconciled: dict[tuple[str, str, str, str, str], dict[str, Any]] = {}
+    for raw in rows:
+        row = dict(raw)
+        key = (
+            str(row.get("ts_code") or ""),
+            str(row.get("l1_code") or ""),
+            str(row.get("l2_code") or ""),
+            str(row.get("l3_code") or ""),
+            str(row.get("in_date") or ""),
+        )
+        current = reconciled.get(key)
+        if current is None:
+            reconciled[key] = row
+            continue
+        current_end = str(current.get("out_date") or "")
+        candidate_end = str(row.get("out_date") or "")
+        if candidate_end and not current_end:
+            current["out_date"] = candidate_end
+            current["is_new"] = row.get("is_new") or current.get("is_new")
+        for field, value in row.items():
+            if not current.get(field) and value not in (None, ""):
+                current[field] = value
+    return list(reconciled.values())
+
+
+def _match_sector_row(rows: list[dict[str, Any]], identifier: str) -> dict[str, Any] | None:
+    if not rows:
+        return None
+    target = identifier.strip().upper()
+    code_match = next(
+        (row for row in rows if str(row.get("ts_code") or "").strip().upper() == target),
+        None,
+    )
+    if code_match:
+        return code_match
+
+    def normalized(value: Any) -> str:
+        text = str(value or "").strip().replace(" ", "")
+        for suffix in ("板块", "概念", "行业"):
+            text = text.removesuffix(suffix)
+        aliases = {
+            "元器件": "元件",
+            "电子元器件": "元件",
+        }
+        return aliases.get(text, text)
+
+    target_name = normalized(identifier)
+    exact = [row for row in rows if normalized(row.get("name")) == target_name]
+    if exact:
+        return min(exact, key=_sector_match_priority)
+    fuzzy = [
+        row for row in rows
+        if target_name and (
+            target_name in normalized(row.get("name"))
+            or normalized(row.get("name")) in target_name
+        )
+    ]
+    return min(
+        fuzzy,
+        key=lambda row: (len(normalized(row.get("name"))), *_sector_match_priority(row)),
+    ) if fuzzy else None
+
+
+def _sector_match_priority(row: dict[str, Any]) -> tuple[int, int, int]:
+    code = str(row.get("ts_code") or "")
+    exchange = str(row.get("exchange") or "").upper()
+    return (
+        0 if exchange == "A" else 1,
+        0 if code.startswith("881") else 1,
+        0 if _number(row.get("count")) > 0 else 1,
+    )

app/backend/data/providers/tushare_sectors.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import math
+import re
+from datetime import datetime, time as dt_time
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_industries import _match_sector_row
+from backend.data.providers.tushare_transport import TushareError
+
+
+class SectorMixin:
+    def sector_snapshot(
+        self,
+        identifier: str,
+        requested_date: str,
+        realtime_expected: bool | None = None,
+    ) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        raw_identifier = identifier.strip()
+        if not raw_identifier:
+            raise TushareError("Sector identifier is empty")
+        errors = []
+        now = datetime.now().astimezone()
+        if realtime_expected is None:
+            realtime_expected = (
+                trade_date == now.strftime("%Y%m%d")
+                and dt_time(9, 15) <= now.time().replace(tzinfo=None) <= dt_time(15, 5)
+            )
+        try:
+            dc_params = {"trade_date": trade_date}
+            if re.fullmatch(r"[A-Z0-9.]+", raw_identifier.upper()) and "." in raw_identifier:
+                dc_params["ts_code"] = raw_identifier.upper()
+            else:
+                dc_params["name"] = raw_identifier
+            dc_rows = self.query(
+                "dc_index",
+                dc_params,
+                "ts_code,trade_date,name,leading,leading_code,pct_change,leading_pct,"
+                "total_mv,turnover_rate,up_num,down_num",
+            )
+            if not dc_rows and "name" in dc_params:
+                dc_rows = self.query(
+                    "dc_index",
+                    {"trade_date": trade_date},
+                    "ts_code,trade_date,name,leading,leading_code,pct_change,leading_pct,"
+                    "total_mv,turnover_rate,up_num,down_num",
+                )
+            dc_row = _match_sector_row(dc_rows, raw_identifier)
+            if dc_row and not realtime_expected:
+                change = _number(dc_row.get("pct_change"))
+                actual_trade_date = str(dc_row.get("trade_date") or "")
+                return {
+                    "code": dc_row.get("ts_code") or "",
+                    "name": dc_row.get("name") or raw_identifier,
+                    "leader": dc_row.get("leading") or "--",
+                    "leader_code": dc_row.get("leading_code") or "",
+                    "leading_pct": _number(dc_row.get("leading_pct")),
+                    "change": change,
+                    "turnover_rate": _number(dc_row.get("turnover_rate")),
+                    "up_count": int(_number(dc_row.get("up_num"))),
+                    "down_count": int(_number(dc_row.get("down_num"))),
+                    "total_mv": _number(dc_row.get("total_mv")),
+                    "strength": round(max(0, min(100, 50 + change * 5)), 1),
+                    "amount_billion": 0,
+                    "count": 0,
+                    "max_streak": 0,
+                    "source": "tushare_dc",
+                    "trade_date": actual_trade_date,
+                    "realtime": False,
+                    "precise": actual_trade_date == trade_date,
+                }
+        except TushareError as exc:
+            errors.append(f"DC: {exc}")
+
+        ts_code = raw_identifier.upper()
+        if re.fullmatch(r"\d{6}", ts_code):
+            ts_code = f"{ts_code}.TI"
+        try:
+            if re.fullmatch(r"\d{6}\.TI", ts_code):
+                index_rows = self.query(
+                    "ths_index",
+                    {"ts_code": ts_code},
+                    "ts_code,name,count,exchange,list_date,type",
+                )
+            else:
+                index_rows = self.query(
+                    "ths_index",
+                    {},
+                    "ts_code,name,count,exchange,list_date,type",
+                )
+            basic = _match_sector_row(index_rows, raw_identifier)
+            if not basic:
+                raise TushareError(f"No THS sector returned for {raw_identifier}")
+        except TushareError as exc:
+            errors.append(f"THS: {exc}")
+            raise TushareError("; ".join(errors)) from exc
+        actual_code = str(basic.get("ts_code") or ts_code)
+        if realtime_expected:
+            try:
+                realtime_sector = self._realtime_sector_snapshot(actual_code, basic, trade_date)
+                if realtime_sector:
+                    return realtime_sector
+            except TushareError as exc:
+                errors.append(f"THS realtime members: {exc}")
+        daily_rows = self.query(
+            "ths_daily",
+            {"ts_code": actual_code, "trade_date": trade_date},
+            "ts_code,trade_date,close,pct_change,vol,turnover_rate,total_mv,float_mv",
+        )
+        daily = daily_rows[0] if daily_rows else {}
+        actual_trade_date = str(daily.get("trade_date") or "")
+        change = _number(daily.get("pct_change"))
+        return {
+            "code": actual_code,
+            "name": basic.get("name") or raw_identifier,
+            "leader": "--",
+            "change": change,
+            "leading_pct": change,
+            "turnover_rate": _number(daily.get("turnover_rate")),
+            "up_count": 0,
+            "down_count": 0,
+            "strength": round(max(0, min(100, 50 + change * 5)), 1),
+            "amount_billion": 0,
+            "count": 0,
+            "max_streak": 0,
+            "source": "tushare_ths",
+            "trade_date": actual_trade_date,
+            "realtime": False,
+            "precise": actual_trade_date == trade_date,
+        }
+
+    def _realtime_sector_snapshot(
+        self,
+        sector_code: str,
+        basic: dict[str, Any],
+        trade_date: str,
+    ) -> dict[str, Any] | None:
+        members = self.query(
+            "ths_member",
+            {"ts_code": sector_code, "is_new": "Y"},
+            "ts_code,con_code,con_name,is_new",
+        )
+        codes = [str(row.get("con_code") or "") for row in members if row.get("con_code")]
+        if not codes:
+            return None
+        quotes = self.query("rt_k", {"ts_code": ",".join(codes)}, "")
+        valid = []
+        for row in quotes:
+            close = _number(row.get("close"))
+            previous_close = _number(row.get("pre_close"))
+            if close <= 0 or previous_close <= 0:
+                continue
+            valid.append(
+                {
+                    **row,
+                    "change": (close / previous_close - 1) * 100,
+                }
+            )
+        minimum = max(1, math.ceil(len(codes) * 0.9))
+        if len(valid) < minimum:
+            raise TushareError(
+                f"Realtime sector coverage is insufficient ({len(valid)}/{len(codes)})"
+            )
+        up_count = sum(item["change"] > 0 for item in valid)
+        down_count = sum(item["change"] < 0 for item in valid)
+        flat_count = len(valid) - up_count - down_count
+        leader = max(valid, key=lambda item: item["change"])
+        change = sum(item["change"] for item in valid) / len(valid)
+        amount_billion = sum(_number(item.get("amount")) for item in valid) / 100000000
+        self._ensure_realtime_market_cache(trade_date)
+        with self._realtime_reference_lock:
+            references = list(self._realtime_reference_cache.values())
+            market_rows = list((self._latest_realtime_market.get(trade_date) or {}).get("rows") or [])
+        capital_map: dict[str, dict[str, Any]] = {}
+        for reference in reversed(references):
+            capital_map = {
+                str(item.get("ts_code") or ""): item
+                for item in reference.get("capital_rows") or []
+            }
+            if capital_map:
+                break
+        sector_turnovers = []
+        for item in valid:
+            capital = capital_map.get(str(item.get("ts_code") or ""), {})
+            float_share = _number(capital.get("float_share"))
+            if float_share:
+                sector_turnovers.append(_number(item.get("vol")) / float_share / 100)
+        market_turnovers = []
+        for item in market_rows:
+            capital = capital_map.get(str(item.get("ts_code") or ""), {})
+            float_share = _number(capital.get("float_share"))
+            if float_share:
+                market_turnovers.append(_number(item.get("vol")) / float_share / 100)
+        average_turnover = sum(sector_turnovers) / len(sector_turnovers) if sector_turnovers else 0
+        market_turnover = sum(market_turnovers) / len(market_turnovers) if market_turnovers else 0
+        relative_turnover = average_turnover / market_turnover if market_turnover else 0
+        return {
+            "code": sector_code,
+            "name": basic.get("name") or sector_code,
+            "leader": str(leader.get("name") or "--").strip(),
+            "leader_code": leader.get("ts_code") or "",
+            "leading_pct": round(leader["change"], 3),
+            "change": round(change, 3),
+            "turnover_rate": round(average_turnover, 4),
+            "market_turnover_rate": round(market_turnover, 4),
+            "relative_turnover": round(relative_turnover, 4),
+            "up_count": up_count,
+            "down_count": down_count,
+            "flat_count": flat_count,
+            "member_count": len(codes),
+            "quote_count": len(valid),
+            "coverage": round(len(valid) / len(codes) * 100, 1),
+            "strength": round(max(0, min(100, 50 + change * 5)), 1),
+            "amount_billion": round(amount_billion, 2),
+            "count": sum(item["change"] >= 9.5 for item in valid),
+            "max_streak": 0,
+            "source": "tushare_rt_ths_members",
+            "trade_date": trade_date,
+            "realtime": True,
+            "precise": True,
+            "methodology": "同花顺行业最新成分股的 rt_k 等权涨跌、宽度与成交额聚合",
+        }

app/backend/data/providers/tushare_stocks.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.bootstrap.config import display_compact_date as _display_date
+from backend.data.numbers import finite_number as _number
+
+
+class StockMixin:
+    def stock_detail(self, ts_code: str, requested_date: str) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        end = datetime.strptime(trade_date, "%Y%m%d")
+        start_date = (end - timedelta(days=190)).strftime("%Y%m%d")
+        daily = self.query(
+            "daily",
+            {"ts_code": ts_code, "start_date": start_date, "end_date": trade_date},
+            "ts_code,trade_date,open,high,low,close,pct_chg,vol,amount",
+        )
+        factors = self.query(
+            "adj_factor",
+            {"ts_code": ts_code, "start_date": start_date, "end_date": trade_date},
+            "ts_code,trade_date,adj_factor",
+        )
+        basics = self.query(
+            "stock_basic",
+            {"ts_code": ts_code},
+            "ts_code,symbol,name,area,industry,market,list_date",
+        )
+        daily_basics = self.query(
+            "daily_basic",
+            {"ts_code": ts_code, "trade_date": trade_date},
+            "ts_code,trade_date,turnover_rate,volume_ratio,total_mv,circ_mv",
+        )
+        moneyflow = self.query(
+            "moneyflow",
+            {"ts_code": ts_code, "trade_date": trade_date},
+            "ts_code,trade_date,buy_sm_amount,sell_sm_amount,buy_md_amount,sell_md_amount,"
+            "buy_lg_amount,sell_lg_amount,buy_elg_amount,sell_elg_amount,net_mf_amount",
+        )
+        factor_map = {row["trade_date"]: _number(row.get("adj_factor"), 1) for row in factors}
+        latest_factor = max(factor_map.values(), default=1) or 1
+        prices = []
+        for row in sorted(daily, key=lambda item: item.get("trade_date", ""))[-90:]:
+            factor = factor_map.get(row.get("trade_date"), latest_factor)
+            ratio = factor / latest_factor
+            prices.append(
+                {
+                    "trade_date": _display_date(str(row.get("trade_date", ""))),
+                    "open": round(_number(row.get("open")) * ratio, 3),
+                    "high": round(_number(row.get("high")) * ratio, 3),
+                    "low": round(_number(row.get("low")) * ratio, 3),
+                    "close": round(_number(row.get("close")) * ratio, 3),
+                    "change": _number(row.get("pct_chg")),
+                    "volume": _number(row.get("vol")),
+                    "amount_billion": round(_number(row.get("amount")) / 100000, 2),
+                }
+            )
+        flow = moneyflow[0] if moneyflow else {}
+        basic = basics[0] if basics else {}
+        daily_basic = daily_basics[0] if daily_basics else {}
+        latest = prices[-1] if prices else {}
+        actual_trade_date = max(
+            (str(row.get("trade_date") or "") for row in daily),
+            default=trade_date,
+        ) or trade_date
+        return {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(actual_trade_date),
+                "source": "tushare",
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "",
+            },
+            "stock": {
+                "code": ts_code.split(".")[0],
+                "ts_code": ts_code,
+                "name": basic.get("name") or "--",
+                "industry": basic.get("industry") or "其他",
+                "area": basic.get("area") or "--",
+                "market": basic.get("market") or "--",
+                "list_date": _display_date(str(basic.get("list_date") or "")),
+                "price": latest.get("close", 0),
+                "change": latest.get("change", 0),
+                "turnover_rate": _number(daily_basic.get("turnover_rate")),
+                "volume_ratio": _number(daily_basic.get("volume_ratio")),
+                "amount_billion": latest.get("amount_billion", 0),
+            },
+            "prices": prices,
+            "moneyflow": {
+                "net_million": round(_number(flow.get("net_mf_amount")) / 100, 2),
+                "large_million": round(
+                    (_number(flow.get("buy_lg_amount")) + _number(flow.get("buy_elg_amount"))
+                     - _number(flow.get("sell_lg_amount")) - _number(flow.get("sell_elg_amount"))) / 100,
+                    2,
+                ),
+                "medium_million": round(
+                    (_number(flow.get("buy_md_amount")) - _number(flow.get("sell_md_amount"))) / 100,
+                    2,
+                ),
+                "small_million": round(
+                    (_number(flow.get("buy_sm_amount")) - _number(flow.get("sell_sm_amount"))) / 100,
+                    2,
+                ),
+            },
+        }
+
+    def stock_intraday(self, ts_code: str, requested_date: str) -> dict[str, Any]:
+        trade_date, _ = self.resolve_trade_context(requested_date)
+        display_date = _display_date(trade_date)
+        rows = self.query(
+            "stk_mins",
+            {
+                "ts_code": ts_code,
+                "freq": "1min",
+                "start_date": f"{display_date} 09:00:00",
+                "end_date": f"{display_date} 15:30:00",
+            },
+            "ts_code,trade_time,open,close,high,low,vol,amount",
+        )
+        points = []
+        for row in sorted(rows, key=lambda item: str(item.get("trade_time") or "")):
+            trade_time = str(row.get("trade_time") or "")
+            if not trade_time:
+                continue
+            points.append(
+                {
+                    "time": trade_time[-8:-3] if len(trade_time) >= 8 else trade_time,
+                    "open": round(_number(row.get("open")), 3),
+                    "high": round(_number(row.get("high")), 3),
+                    "low": round(_number(row.get("low")), 3),
+                    "close": round(_number(row.get("close")), 3),
+                    "volume": _number(row.get("vol")),
+                    "amount": _number(row.get("amount")),
+                }
+            )
+        return {"trade_date": display_date, "points": points}

app/backend/data/providers/tushare_transport.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.request
+from typing import Any
+
+
+TUSHARE_URL = "http://api.tushare.pro"
+
+
+class TushareError(RuntimeError):
+    pass
+
+
+class TushareTransportMixin:
+    def query(
+        self,
+        api_name: str,
+        params: dict[str, Any] | None = None,
+        fields: str = "",
+    ) -> list[dict[str, Any]]:
+        payload = json.dumps(
+            {
+                "api_name": api_name,
+                "token": self.token,
+                "params": params or {},
+                "fields": fields,
+            }
+        ).encode("utf-8")
+        request = urllib.request.Request(
+            TUSHARE_URL,
+            data=payload,
+            headers={"Content-Type": "application/json", "User-Agent": "XiaobaiReviewWeb/0.2"},
+            method="POST",
+        )
+        try:
+            with urllib.request.urlopen(request, timeout=self.timeout) as response:
+                result = json.loads(response.read().decode("utf-8"))
+        except (urllib.error.URLError, TimeoutError, json.JSONDecodeError) as exc:
+            raise TushareError(f"Tushare request failed: {exc}") from exc
+
+        if result.get("code") != 0:
+            raise TushareError(result.get("msg") or "Tushare returned an unknown error")
+
+        data = result.get("data") or {}
+        columns = data.get("fields") or []
+        return [dict(zip(columns, item)) for item in data.get("items") or []]

app/backend/database/migrations/__init__.py

@@ -1,8 +1,14 @@
 from .m0001_adopt_legacy import MIGRATION as M0001_ADOPT_LEGACY
 from .m0002_job_runs import MIGRATION as M0002_JOB_RUNS
 from .m0003_llm_audit import MIGRATION as M0003_LLM_AUDIT
+from .m0004_mentor_notes import MIGRATION as M0004_MENTOR_NOTES
 from .runner import Migration, MigrationError, MigrationRunner
 
-MIGRATIONS = (M0001_ADOPT_LEGACY, M0002_JOB_RUNS, M0003_LLM_AUDIT)
+MIGRATIONS = (
+    M0001_ADOPT_LEGACY,
+    M0002_JOB_RUNS,
+    M0003_LLM_AUDIT,
+    M0004_MENTOR_NOTES,
+)
 
 __all__ = ["MIGRATIONS", "Migration", "MigrationError", "MigrationRunner"]

app/backend/database/migrations/m0004_mentor_notes.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import sqlite3
+
+from backend.database.migrations.runner import Migration
+
+
+def add_mentor_note(connection: sqlite3.Connection) -> None:
+    columns = {
+        str(row["name"])
+        for row in connection.execute("PRAGMA table_info(mentor_preferences)")
+    }
+    if "note" not in columns:
+        connection.execute(
+            "ALTER TABLE mentor_preferences ADD COLUMN note TEXT NOT NULL DEFAULT ''"
+        )
+
+
+MIGRATION = Migration(
+    version="0004",
+    name="add_mentor_note",
+    action=add_mentor_note,
+    signature="mentor-preferences-note:v1:note",
+)

app/backend/features/accounts/application.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.features.accounts.service import AccountService
+
+
+class AccountApplicationMixin:
+    def bind_user(self, user_id: int) -> None:
+        self._request_context.user_id = int(user_id)
+        encrypted = self.database.get_user_credentials(int(user_id))
+        self._request_context.credentials = self.vault.decrypt_json(encrypted) if encrypted else {}
+        self._request_context.access = self.database.user_access(int(user_id)) or {}
+
+    @property
+    def current_user_id(self) -> int:
+        user_id = getattr(self._request_context, "user_id", 0)
+        if not user_id:
+            raise ValueError("当前请求尚未绑定账号。")
+        return int(user_id)
+
+    def membership(self) -> dict[str, Any]:
+        return self.accounts.membership()
+
+    def admin_users(self) -> list[dict[str, Any]]:
+        return self.accounts.admin_users(self._platform_usage_today_for_user)
+
+    def update_membership(self, payload: dict[str, Any]) -> None:
+        self.accounts.update_membership(payload)
+
+    def register_account(self, username: str, password: str) -> dict[str, Any]:
+        return self.accounts.register(username, password)
+
+    def login_account(self, username: str, password: str) -> dict[str, Any]:
+        return self.accounts.login(username, password)
+
+    def change_password(self, current_password: str, new_password: str) -> None:
+        self.accounts.change_password(current_password, new_password)
+
+    def create_account_session(self, user: dict[str, Any]) -> dict[str, Any]:
+        return self.accounts.create_session(user)
+
+    @staticmethod
+    def _validate_account_input(username: str, password: str) -> None:
+        AccountService.validate_input(username, password)
+
+    def save_birth_profile(self, payload: dict[str, Any]) -> dict[str, Any]:
+        return self.accounts.save_birth_profile(payload)
+
+    def stored_birth_profile(self) -> dict[str, str] | None:
+        return self.accounts.stored_birth_profile()
+
+    def account_personal_field(
+        self,
+        current_date: str,
+        current_field: dict[str, Any],
+        public: bool = False,
+    ) -> dict[str, Any] | None:
+        return self.accounts.personal_field(current_date, current_field, public)
+
+    @staticmethod
+    def _public_personal_profile(personal: dict[str, Any]) -> dict[str, Any]:
+        return AccountService.public_personal_profile(personal)

app/backend/features/accounts/routes.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+
+class AccountRoutesMixin:
+    def _handle_accounts_public_get(self, parsed) -> bool:
+        if parsed.path == "/api/auth/me":
+            self.auth_me()
+            return True
+        return False
+
+    def _handle_accounts_get(self, parsed) -> bool:
+        if parsed.path == "/api/account/status":
+            self.send_json({"ok": True, **self.application_service.status()})
+            return True
+        return False
+
+    def _handle_accounts_delete(self, parsed) -> bool:
+        if parsed.path == "/api/account/birth-profile":
+            deleted = self.application_service.database.delete_user_birth_profile(self.application_service.current_user_id)
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        return False

app/backend/features/alerts/__init__.py

@@ -1,3 +1,18 @@
-from .service import AlertService
+from .facade import AlertServiceMixin
+from .http import AlertHttpMixin
+from .repository import AlertRepositoryMixin
 
-__all__ = ["AlertService"]
+__all__ = [
+    "AlertHttpMixin",
+    "AlertRepositoryMixin",
+    "AlertService",
+    "AlertServiceMixin",
+]
+
+
+def __getattr__(name: str):
+    if name == "AlertService":
+        from .service import AlertService
+
+        return AlertService
+    raise AttributeError(name)

app/backend/features/alerts/facade.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import date
+from typing import Any
+
+
+class AlertServiceMixin:
+    def alert_center(self, status: str = "all", as_of: str = "") -> dict[str, Any]:
+        tracking = self.strategy_tracking.list_tracking(self.current_user_id, 12)
+        self.alert_service.sync_strategy_tracking(self.current_user_id, tracking)
+        return self.alert_service.list_alerts(
+            self.current_user_id, status, as_of
+        )
+
+    def create_alert(self, payload: dict[str, Any]) -> dict[str, Any]:
+        alert_id = self.alert_service.create_manual(self.current_user_id, payload)
+        return {"id": alert_id, **self.alert_center()}
+
+    def mark_alert_read(self, alert_id: int) -> dict[str, Any]:
+        self.alert_service.mark_read(self.current_user_id, alert_id)
+        return self.alert_center()
+
+    def mark_all_alerts_read(self, as_of: str = "") -> dict[str, Any]:
+        compact_date = self.alert_service.calendar_date(as_of or date.today().isoformat())
+        self.alert_service.mark_all_read(self.current_user_id, compact_date)
+        return self.alert_center(as_of=compact_date)
+
+    def delete_alert(self, alert_id: int) -> dict[str, Any]:
+        deleted = self.alert_service.delete(self.current_user_id, alert_id)
+        return {"deleted": deleted, **self.alert_center()}

app/backend/features/alerts/http.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+import json
+from http import HTTPStatus
+
+
+class AlertHttpMixin:
+    def save_alert(self) -> None:
+        try:
+            body = self.read_json_body()
+            self.send_json(
+                {"ok": True, **self.application_service.create_alert(body)},
+                HTTPStatus.CREATED,
+            )
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/alerts/repository.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+
+class AlertRepositoryMixin:
+    def save_alert(
+        self,
+        user_id: int,
+        kind: str,
+        title: str,
+        content: str,
+        available_date: str,
+        code: str,
+        dedupe_key: str,
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO alerts
+                    (user_id, kind, title, content, available_date, code, dedupe_key,
+                     is_read, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, 0, ?, ?)
+                ON CONFLICT(user_id, dedupe_key) DO UPDATE SET
+                    title=excluded.title, content=excluded.content,
+                    available_date=excluded.available_date, updated_at=excluded.updated_at
+                """,
+                (
+                    int(user_id), kind, title, content, available_date, code,
+                    dedupe_key, now, now,
+                ),
+            )
+            row = connection.execute(
+                "SELECT id FROM alerts WHERE user_id = ? AND dedupe_key = ?",
+                (int(user_id), dedupe_key),
+            ).fetchone()
+        return int(row["id"])
+
+    def list_alerts(
+        self, user_id: int, as_of: str, unread_only: bool = False, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            if unread_only:
+                rows = connection.execute(
+                    """
+                    SELECT id, kind, title, content, available_date, code, is_read,
+                           created_at, updated_at, read_at
+                    FROM alerts
+                    WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                    ORDER BY available_date DESC, id DESC LIMIT ?
+                    """,
+                    (int(user_id), as_of, max(1, min(300, int(limit)))),
+                ).fetchall()
+            else:
+                rows = connection.execute(
+                    """
+                    SELECT id, kind, title, content, available_date, code, is_read,
+                           created_at, updated_at, read_at
+                    FROM alerts WHERE user_id = ?
+                    ORDER BY CASE WHEN available_date > ? THEN 0 ELSE 1 END,
+                             is_read, available_date, id DESC LIMIT ?
+                    """,
+                    (int(user_id), as_of, max(1, min(300, int(limit)))),
+                ).fetchall()
+        return [{**dict(row), "is_read": bool(row["is_read"])} for row in rows]
+
+    def count_unread_alerts(self, user_id: int, as_of: str) -> int:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT COUNT(*) AS total FROM alerts
+                WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                """,
+                (int(user_id), as_of),
+            ).fetchone()
+        return int(row["total"] if row else 0)
+
+    def mark_alert_read(self, user_id: int, alert_id: int) -> bool:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            cursor = connection.execute(
+                """
+                UPDATE alerts SET is_read = 1, read_at = ?, updated_at = ?
+                WHERE id = ? AND user_id = ?
+                """,
+                (now, now, int(alert_id), int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def mark_all_alerts_read(self, user_id: int, as_of: str) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            cursor = connection.execute(
+                """
+                UPDATE alerts SET is_read = 1, read_at = ?, updated_at = ?
+                WHERE user_id = ? AND available_date <= ? AND is_read = 0
+                """,
+                (now, now, int(user_id), as_of),
+            )
+            return int(cursor.rowcount)
+
+    def delete_alert(self, user_id: int, alert_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM alerts WHERE id = ? AND user_id = ?",
+                (int(alert_id), int(user_id)),
+            )
+            return cursor.rowcount > 0

app/backend/features/alerts/routes.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+
+
+class AlertRoutesMixin:
+    def _handle_alerts_get(self, parsed) -> bool:
+        if parsed.path == "/api/alerts":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.alert_center(
+                        query.get("status", ["all"])[0],
+                        query.get("as_of", [date.today().isoformat()])[0],
+                    )
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False
+
+    def _handle_alerts_post(self, parsed) -> bool:
+        alert_read_match = re.fullmatch(r"/api/alerts/(\d+)/read", parsed.path)
+        if alert_read_match:
+            self.send_json(
+                {"ok": True, **self.application_service.mark_alert_read(int(alert_read_match.group(1)))}
+            )
+            return True
+        if parsed.path == "/api/alerts/read-all":
+            body = self.read_json_body(True)
+            self.send_json(
+                {"ok": True, **self.application_service.mark_all_alerts_read(str(body.get("as_of") or ""))}
+            )
+            return True
+        return False
+
+    def _handle_alerts_delete(self, parsed) -> bool:
+        alert_match = re.fullmatch(r"/api/alerts/(\d+)", parsed.path)
+        if alert_match:
+            self.send_json(
+                {"ok": True, **self.application_service.delete_alert(int(alert_match.group(1)))}
+            )
+            return True
+        return False

app/backend/features/auction/__init__.py

@@ -0,0 +1,4 @@
+from .repository import AuctionRepositoryMixin
+from .service import AuctionServiceMixin
+
+__all__ = ["AuctionRepositoryMixin", "AuctionServiceMixin"]

app/backend/features/auction/repository.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class AuctionRepositoryMixin:
+    def upsert_auction_factors(self, rows: list[dict[str, Any]]) -> int:
+        values = []
+        for row in rows:
+            trade_date = str(row.get("trade_date") or "")
+            ts_code = str(row.get("ts_code") or "")
+            price = float(row.get("price") or 0)
+            pre_close = float(row.get("pre_close") or 0)
+            if not trade_date or not ts_code or price <= 0 or pre_close <= 0:
+                continue
+            values.append(
+                (
+                    trade_date,
+                    ts_code,
+                    price,
+                    pre_close,
+                    (price / pre_close - 1) * 100,
+                    float(row.get("vol") or 0),
+                    float(row.get("amount") or 0),
+                    float(row.get("turnover_rate") or 0),
+                    float(row.get("volume_ratio") or 0),
+                )
+            )
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO auction_factors
+                    (trade_date, ts_code, price, pre_close, change, vol, amount,
+                     turnover_rate, volume_ratio)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    price=excluded.price, pre_close=excluded.pre_close,
+                    change=excluded.change, vol=excluded.vol, amount=excluded.amount,
+                    turnover_rate=excluded.turnover_rate,
+                    volume_ratio=excluded.volume_ratio
+                """,
+                values,
+            )
+        return len(values)
+
+    def auction_factor_dates(self, end_date: str = "", limit: int = 80) -> list[str]:
+        where = "WHERE trade_date <= ?" if end_date else ""
+        parameters: tuple[Any, ...] = (end_date, limit) if end_date else (limit,)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"SELECT DISTINCT trade_date FROM auction_factors {where} "
+                "ORDER BY trade_date DESC LIMIT ?",
+                parameters,
+            ).fetchall()
+        return [row["trade_date"] for row in reversed(rows)]
+
+    def auction_factors_for_date(self, trade_date: str) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT * FROM auction_factors WHERE trade_date = ? ORDER BY ts_code",
+                (trade_date,),
+            ).fetchall()
+        return [dict(row) for row in rows]

app/backend/features/auction/routes.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+from backend.data.providers.tushare_client import TushareError
+
+
+class AuctionRoutesMixin:
+    def _handle_auction_get(self, parsed) -> bool:
+        if parsed.path == "/api/auction":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.auction_center(
+                        query.get("trade_date", [date.today().isoformat()])[0],
+                        query.get("force", ["0"])[0] == "1",
+                    )
+                )
+            except (ValueError, TushareError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False

app/backend/features/auction/service.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.bootstrap.config import normalize_date
+from backend.features.market.insights import MarketInsightsService
+
+
+class AuctionServiceMixin:
+    def auction_center(self, trade_date: str, force: bool = False) -> dict[str, Any]:
+        return self._market_insights().auction_center(
+            normalize_date(trade_date), force, self.current_user_id
+        )

app/backend/features/dragon_tiger/__init__.py

@@ -0,0 +1,4 @@
+from .repository import DragonTigerRepositoryMixin
+from .service import DragonTigerServiceMixin
+
+__all__ = ["DragonTigerRepositoryMixin", "DragonTigerServiceMixin"]

app/backend/features/dragon_tiger/repository.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+
+class DragonTigerRepositoryMixin:
+    def list_seat_aliases(self) -> dict[str, str]:
+        with self.connect() as connection:
+            rows = connection.execute("SELECT seat_name, alias FROM seat_aliases").fetchall()
+        return {row["seat_name"]: row["alias"] for row in rows}
+
+    def save_seat_alias(self, seat_name: str, alias: str) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO seat_aliases (seat_name, alias, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(seat_name) DO UPDATE SET
+                    alias = excluded.alias,
+                    updated_at = excluded.updated_at
+                """,
+                (seat_name, alias, now),
+            )
+
+    def upsert_lhb_institutions(self, rows: list[dict[str, Any]]) -> int:
+        grouped: dict[tuple[str, str], dict[str, float | int]] = {}
+        for row in rows:
+            trade_date = str(row.get("trade_date") or "")
+            ts_code = str(row.get("ts_code") or "")
+            seat_name = str(row.get("exalter") or row.get("seat_name") or "")
+            if not trade_date or not ts_code or "机构专用" not in seat_name:
+                continue
+            group = grouped.setdefault(
+                (trade_date, ts_code),
+                {"net": 0.0, "buy": 0.0, "sell": 0.0, "seats": 0},
+            )
+            group["net"] = float(group["net"]) + float(row.get("net_buy") or row.get("net_amount") or 0)
+            group["buy"] = float(group["buy"]) + float(row.get("buy") or row.get("buy_amount") or 0)
+            group["sell"] = float(group["sell"]) + float(row.get("sell") or row.get("sell_amount") or 0)
+            group["seats"] = int(group["seats"]) + 1
+        values = [
+            (trade_date, ts_code, item["net"], item["buy"], item["sell"], item["seats"])
+            for (trade_date, ts_code), item in grouped.items()
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO lhb_institution_daily
+                    (trade_date, ts_code, net_buy_amount, buy_amount, sell_amount, seat_count)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    net_buy_amount=excluded.net_buy_amount,
+                    buy_amount=excluded.buy_amount,
+                    sell_amount=excluded.sell_amount,
+                    seat_count=excluded.seat_count
+                """,
+                values,
+            )
+        return len(values)

app/backend/features/dragon_tiger/routes.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import json
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+from backend.bootstrap.config import validate_text
+
+
+class DragonTigerRoutesMixin:
+    def _handle_dragon_tiger_get(self, parsed) -> bool:
+        if parsed.path == "/api/dragon-tiger":
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            force = query.get("force", ["0"])[0] == "1"
+            try:
+                self.send_json(self.application_service.get_dragon_tiger(trade_date, force))
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/dragon-tiger/profiles":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.get_hot_money_profiles(
+                        query.get("force", ["0"])[0] == "1"
+                    )
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/seat-aliases":
+            self.send_json({"items": self.application_service.database.list_seat_aliases()})
+            return True
+        return False
+
+    def save_seat_alias(self) -> None:
+        try:
+            body = self.read_json_body()
+            seat_name = validate_text(body.get("seat_name"), "席位名称", 200, required=True)
+            alias = validate_text(body.get("alias"), "席位别名", 50, required=True)
+            self.application_service.database.save_seat_alias(seat_name, alias)
+            self.send_json({"ok": True})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/dragon_tiger/service.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from backend.bootstrap.config import normalize_date
+from backend.data.providers.tushare_client import TushareError
+
+
+class DragonTigerServiceMixin:
+    def get_hot_money_profiles(self, force: bool = False) -> dict[str, Any]:
+        cache_kind = "hot_money_profiles_v1"
+        cache_key = "directory"
+        cached = self.database.get_data_snapshot(cache_kind, cache_key)
+        if cached and not force:
+            cached["meta"] = {**cached.get("meta", {}), "cached": True}
+            return cached
+        if self.configured:
+            try:
+                payload = self._tushare_client().hot_money_profiles()
+            except TushareError:
+                if cached:
+                    cached["meta"] = {
+                        **cached.get("meta", {}),
+                        "cached": True,
+                        "stale": True,
+                        "notice": "名录暂未完成更新，当前展示最近一次收录结果。",
+                    }
+                    return cached
+                return {
+                    "meta": {
+                        "source": "unavailable",
+                        "status": "unavailable",
+                        "schema_version": 1,
+                        "cached": False,
+                        "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                        "notice": "游资名录暂不可用，请稍后重试。",
+                    },
+                    "summary": {
+                        "profile_count": 0,
+                        "described_count": 0,
+                        "organization_count": 0,
+                    },
+                    "profiles": [],
+                }
+            payload["meta"]["cached"] = False
+            if payload.get("meta", {}).get("status") == "success":
+                self.database.save_data_snapshot(cache_kind, cache_key, "tushare", payload)
+            return payload
+        if cached:
+            cached["meta"] = {**cached.get("meta", {}), "cached": True}
+            return cached
+        return {
+            "meta": {
+                "source": "unavailable",
+                "status": "unavailable",
+                "schema_version": 1,
+                "cached": False,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "游资名录暂不可用，请联系管理员检查行情配置。",
+            },
+            "summary": {
+                "profile_count": 0,
+                "described_count": 0,
+                "organization_count": 0,
+            },
+            "profiles": [],
+        }
+
+    def get_dragon_tiger(self, trade_date: str, force: bool = False) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        cache_kind = "hot_money_detail_v3"
+        if not force:
+            cached = self.database.get_data_snapshot(cache_kind, normalized_date)
+            if (
+                cached
+                and cached.get("meta", {}).get("source") == "tushare"
+                and cached.get("meta", {}).get("status") == "success"
+                and int(cached.get("meta", {}).get("schema_version") or 0) == 3
+            ):
+                cached["meta"] = {**cached.get("meta", {}), "cached": True}
+                return cached
+        if self.configured:
+            try:
+                payload = self._tushare_client().dragon_tiger(normalized_date)
+            except TushareError as exc:
+                return {
+                    "meta": {
+                        "requested_date": f"{normalized_date[:4]}-{normalized_date[4:6]}-{normalized_date[6:8]}",
+                        "trade_date": f"{normalized_date[:4]}-{normalized_date[4:6]}-{normalized_date[6:8]}",
+                        "source": "tushare_error",
+                        "status": "error",
+                        "schema_version": 3,
+                        "cached": False,
+                        "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                        "notice": "龙虎榜数据暂不可用，请稍后重试。",
+                    },
+                    "summary": {
+                        "trader_count": 0,
+                        "identity_count": 0,
+                        "operation_count": 0,
+                        "active_stock_count": 0,
+                        "seat_net_buy_million": 0,
+                        "unclassified_count": 0,
+                        "directory_count": 0,
+                    },
+                    "traders": [],
+                    "unclassified_seats": [],
+                    "rows": [],
+                }
+            payload["meta"]["cached"] = False
+            if payload.get("meta", {}).get("status") == "success":
+                self.database.save_data_snapshot(cache_kind, normalized_date, "tushare", payload)
+            return payload
+
+        return {
+            "meta": {
+            "requested_date": f"{normalized_date[:4]}-{normalized_date[4:6]}-{normalized_date[6:8]}",
+            "trade_date": f"{normalized_date[:4]}-{normalized_date[4:6]}-{normalized_date[6:8]}",
+            "source": "unavailable",
+            "status": "unavailable",
+            "schema_version": 3,
+            "cached": False,
+            "notice": "龙虎榜数据暂不可用，请联系管理员检查行情配置。",
+            },
+            "summary": {
+                "trader_count": 0,
+                "identity_count": 0,
+                "operation_count": 0,
+                "active_stock_count": 0,
+                "seat_net_buy_million": 0,
+                "unclassified_count": 0,
+                "directory_count": 0,
+            },
+            "traders": [],
+            "unclassified_seats": [],
+            "rows": [],
+        }
+
+    def _apply_seat_aliases(self, payload: dict[str, Any]) -> dict[str, Any]:
+        aliases = self.database.list_seat_aliases()
+        result = dict(payload)
+        rows = payload.get("rows") or []
+        for row in rows:
+            for institution in row.get("institutions") or []:
+                institution["alias"] = aliases.get(institution.get("seat_name", ""), "")
+        traders: dict[tuple[str, str], dict[str, Any]] = {}
+        unclassified: dict[str, dict[str, Any]] = {}
+        seen_operations: set[tuple[Any, ...]] = set()
+        builtin_aliases = {
+            "国泰海通证券股份有限公司南京太平南路证券营业部": "作手新一",
+        }
+
+        for row in rows:
+            for institution in row.get("institutions") or []:
+                seat_name = str(institution.get("seat_name") or "未知席位").strip()
+                saved_alias = str(institution.get("alias") or "").strip()
+                builtin_alias = builtin_aliases.get(seat_name, "")
+                if saved_alias or builtin_alias:
+                    identity_name = saved_alias or builtin_alias
+                    identity_type = "trader"
+                    recognized = True
+                    identity_source = "manual" if saved_alias else "builtin"
+                elif "机构专用" in seat_name:
+                    identity_name = "机构专用"
+                    identity_type = "institution"
+                    recognized = True
+                    identity_source = "system"
+                elif "沪股通专用" in seat_name or "深股通专用" in seat_name:
+                    identity_name = "北向资金"
+                    identity_type = "channel"
+                    recognized = True
+                    identity_source = "system"
+                else:
+                    identity_name = seat_name
+                    identity_type = "unclassified"
+                    recognized = False
+                    identity_source = "raw"
+
+                buy = round(float(institution.get("buy_million") or 0), 2)
+                sell = round(float(institution.get("sell_million") or 0), 2)
+                net_buy = round(float(institution.get("net_buy_million") or 0), 2)
+                operation_key = (row.get("code"), seat_name, buy, sell, net_buy)
+                if operation_key in seen_operations:
+                    continue
+                seen_operations.add(operation_key)
+
+                group_key = (identity_type, identity_name)
+                group = traders.setdefault(
+                    group_key,
+                    {
+                        "name": identity_name,
+                        "identity_type": identity_type,
+                        "identity_source": identity_source,
+                        "recognized": recognized,
+                        "buy_million": 0.0,
+                        "sell_million": 0.0,
+                        "net_buy_million": 0.0,
+                        "seat_names": set(),
+                        "stock_codes": set(),
+                        "operations": [],
+                    },
+                )
+                group["buy_million"] += buy
+                group["sell_million"] += sell
+                group["net_buy_million"] += net_buy
+                group["seat_names"].add(seat_name)
+                group["stock_codes"].add(str(row.get("code") or ""))
+                group["operations"].append(
+                    {
+                        "code": row.get("code") or "",
+                        "name": row.get("name") or "--",
+                        "change": row.get("change") or 0,
+                        "direction": "买入" if net_buy > 0 else "卖出" if net_buy < 0 else "持平",
+                        "buy_million": buy,
+                        "sell_million": sell,
+                        "net_buy_million": net_buy,
+                        "reason": row.get("reason") or "--",
+                        "seat_name": seat_name,
+                        "seat_alias": identity_name if recognized else "",
+                    }
+                )
+
+                if not recognized:
+                    pending = unclassified.setdefault(
+                        seat_name,
+                        {
+                            "seat_name": seat_name,
+                            "stock_codes": set(),
+                            "operation_count": 0,
+                            "buy_million": 0.0,
+                            "sell_million": 0.0,
+                            "net_buy_million": 0.0,
+                        },
+                    )
+                    pending["stock_codes"].add(str(row.get("code") or ""))
+                    pending["operation_count"] += 1
+                    pending["buy_million"] += buy
+                    pending["sell_million"] += sell
+                    pending["net_buy_million"] += net_buy
+
+        type_order = {"trader": 0, "institution": 1, "channel": 2, "unclassified": 3}
+        aggregated = list(traders.values())
+        aggregated.sort(
+            key=lambda item: (
+                type_order.get(item["identity_type"], 9),
+                -abs(item["net_buy_million"]),
+                item["name"],
+            )
+        )
+        for index, group in enumerate(aggregated, start=1):
+            group["id"] = f"identity-{index}"
+            group["buy_million"] = round(group["buy_million"], 2)
+            group["sell_million"] = round(group["sell_million"], 2)
+            group["net_buy_million"] = round(group["net_buy_million"], 2)
+            group["seat_count"] = len(group.pop("seat_names"))
+            group["stock_count"] = len(group.pop("stock_codes"))
+            group["operation_count"] = len(group["operations"])
+            group["operations"].sort(
+                key=lambda item: abs(float(item.get("net_buy_million") or 0)), reverse=True
+            )
+
+        pending_seats = list(unclassified.values())
+        for pending in pending_seats:
+            pending["stock_count"] = len(pending.pop("stock_codes"))
+            pending["buy_million"] = round(pending["buy_million"], 2)
+            pending["sell_million"] = round(pending["sell_million"], 2)
+            pending["net_buy_million"] = round(pending["net_buy_million"], 2)
+        pending_seats.sort(key=lambda item: abs(item["net_buy_million"]), reverse=True)
+
+        operation_count = sum(item["operation_count"] for item in aggregated)
+        active_stocks = {
+            operation["code"] for item in aggregated for operation in item["operations"]
+        }
+        seat_net_buy = round(sum(item["net_buy_million"] for item in aggregated), 2)
+        result["rows"] = rows
+        result["traders"] = aggregated
+        result["unclassified_seats"] = pending_seats
+        result["summary"] = {
+            **(payload.get("summary") or {}),
+            "trader_count": sum(item["identity_type"] == "trader" for item in aggregated),
+            "identity_count": len(aggregated),
+            "operation_count": operation_count,
+            "active_stock_count": len(active_stocks),
+            "seat_net_buy_million": seat_net_buy,
+            "unclassified_count": len(pending_seats),
+        }
+        return result

app/backend/features/heaven/__init__.py

@@ -0,0 +1,24 @@
+from .agent import HeavenAgentError, interpret_heaven
+from .engine import (
+    build_five_phase_field,
+    build_market_hexagram,
+    build_manual_market_hexagram,
+    build_personal_field,
+    hexagram_from_lines,
+)
+from .http import HeavenHttpMixin
+from .repository import HeavenRepositoryMixin
+from .service import HeavenServiceMixin
+
+__all__ = [
+    "HeavenAgentError",
+    "HeavenHttpMixin",
+    "HeavenRepositoryMixin",
+    "HeavenServiceMixin",
+    "build_five_phase_field",
+    "build_manual_market_hexagram",
+    "build_market_hexagram",
+    "build_personal_field",
+    "hexagram_from_lines",
+    "interpret_heaven",
+]

app/backend/features/heaven/agent.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from backend.llm import transport as llm_transport
+
+
+class HeavenAgentError(RuntimeError):
+    pass
+
+
+HEAVEN_PROMPT_VERSIONS = {
+    "trend": "heaven-trend-v4",
+    "fortune": "heaven-fortune-v9",
+    "heart": "heaven-heart-v5",
+}
+
+
+def interpret_heaven(
+    mode: str,
+    context: dict[str, Any],
+    api_key: str,
+    base_url: str,
+    model: str,
+    timeout: int = 90,
+) -> dict[str, Any]:
+    if mode not in {"trend", "fortune", "heart"}:
+        raise HeavenAgentError("不支持的问天解读模式。")
+    if not api_key or not model:
+        raise HeavenAgentError("LLM API Key 或模型尚未配置。")
+    system_prompt = _system_prompt(mode)
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {
+            "role": "user",
+            "content": json.dumps(context, ensure_ascii=False, separators=(",", ":")),
+        },
+    ]
+    try:
+        result = llm_transport.chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=messages,
+            timeout=timeout,
+            user_agent="XiaobaiReviewWeb/0.7",
+        )
+        answer = str(result.content).strip()
+        if not answer:
+            raise KeyError("empty response")
+        try:
+            _validate_answer(mode, answer, context)
+        except HeavenAgentError as validation_error:
+            repair_messages = [
+                *messages,
+                {"role": "assistant", "content": answer},
+                {
+                    "role": "user",
+                    "content": (
+                        f"上一版未通过本地一致性校验：{validation_error}"
+                        "请依据最初输入完整重写最终答案，只修正违规推断并补齐必答项。"
+                        "不得讨论校验、提示词或重写过程，只输出新的正式解读。"
+                    ),
+                },
+            ]
+            repaired = llm_transport.chat_completion(
+                api_key=api_key,
+                base_url=base_url,
+                model=model,
+                messages=repair_messages,
+                timeout=timeout,
+                user_agent="XiaobaiReviewWeb/0.7",
+            )
+            answer = str(repaired.content).strip()
+            if not answer:
+                raise KeyError("empty repaired response")
+            _validate_answer(mode, answer, context)
+            result = repaired
+    except llm_transport.OpenAIHTTPError as exc:
+        raise HeavenAgentError(exc.describe("问天模型调用失败")) from exc
+    except (llm_transport.OpenAITransportError, KeyError) as exc:
+        raise HeavenAgentError(f"问天模型调用失败：{exc}") from exc
+    return {
+        "answer": answer,
+        "model": model,
+        "latency_ms": result.latency_ms,
+    }
+
+
+def _system_prompt(mode: str) -> str:
+    common = """
+你是“小白复盘”的问天解读器。输入由calculation、knowledge和interpretation_contract组成：calculation是确定性程序已经算出的事实；knowledge是本次按条件精确检索到的原典、传统规则和产品边界；interpretation_contract规定本次必须回答与禁止推断的内容。
+只能综合输入中已经提供的事实和知识。不得改卦、改爻、改纳甲、改世应、改干支、重新计算五运六气，也不得凭模型记忆补造缺失字段。知识记录之间若存在张力，应说明条件与分歧，不要强行合成唯一结论。
+问天属于传统文化与自我观察，不是可验证的行情预测模型。必须给出有内容的倾向和依据，但不得把象义宣布为必然发生的股价结果，不输出无条件买卖指令，不用神秘话术制造确定性。
+使用中文和普通用户能够理解的表达。专业术语首次出现时紧接一句白话解释。先给核心判断，再说明证据和变化关系。每个主题必须使用独立一行的简短标题，格式为“## 标题”，标题后另起一段正文；不得把全部内容挤在一个长段落中。可以使用Markdown加粗，不使用Markdown表格。
+""".strip()
+    if mode == "trend":
+        return common + """
+
+当前任务是“观势·解势”。行情只负责在进入模型之前生成卦象，本次回答不得引用或反推指数涨跌、成交额、涨跌停、板块强弱或个股表现，也不得说明某一爻原先对应哪类市场指标。
+calculation中有意不提供股票、行业和板块身份。不得猜测或讨论观察对象所属行业、政策、消费环境、基本面、资金面或任何现实市场变量；只解释已经生成的卦象。
+必须明确给出卦义上的当下倾向、主要矛盾、实际动爻所示的转折，以及本卦走向之卦后的变化方向。允许使用偏进、偏守、先难后易、由盛转收、转机有限、内外相违或结论有条件等相对判断；不得只罗列卦辞，也不得用“谨慎、等待、守信、辨伪”一类泛化劝诫代替解势。
+以knowledge中本卦、上下卦、卦辞、彖义、大象、实际动爻和之卦记录为依据。无动爻、一动爻和多动爻分别服从本次检索到的方法规则；多动爻有冲突时必须指出冲突，不得压成单一套话。
+按“## 核心判断、## 卦势依据、## 动爻转折、## 之卦趋向、## 决策映射”组织答案；无动爻时仍保留“动爻转折”，明确说明本次无动爻并解释结构的延续条件。结尾可以把卦势翻译成克制的交易决策语言，但只能表达条件、节奏和需要验证的矛盾，不得预测具体涨跌、价格、日期或给出直接荐股结论。篇幅随动爻数量自然展开，不设置固定字数。
+""".strip()
+    if mode == "fortune":
+        return common + """
+
+当前任务是“观气·解运”。页面用于直观展示的五行权重、主导元素和预制复合断语已明确排除，不得自行恢复这些结果，也不得按百分比重新生成单一五行结论。
+严格区分中运、司天在泉、当前主气客气、节气定位和日辰触发。先解释中运与司天在泉构成的年纲，再解释客气加临主气的当前关系，最后说明日辰如何触发；不得把同一项拆成多份证据重复计权。相生不直接等于吉，相克不直接等于凶。
+必须使用knowledge中与本日中运、六气和客主关系精确匹配的记录。可形成“湿热交蒸、燥中夹滞”一类复合表达，但要从输入关系逐层说明，不能从页面权重结论倒推。
+如calculation.personal存在，只结合日主、十神和当日派生关系说明用户容易出现的主观感受与判断偏差；不得使用简化强弱、喜用神、出生日期或权重平衡结论。
+personal.natal_day_master才是用户本命日主；today_relative_to_natal_day_master.pillars是当日历法，不是用户出生四柱。stem_relations只是当日年、月、日三柱天干相对本命日主的程序结果，只能使用knowledge中本次命中的关系释义，不得自行重算十神或扩展五行生克过程。不得使用藏干、支中藏某干、某支为某库或燥湿属性等输入未提供的信息，也不得把当日日柱写成用户命局，或推断用户命局中某个十神“较重”、身强身弱或喜用神。
+日辰只按calculation.day_trigger.summary与knowledge中的日辰边界解释，不得从干支另行推导藏气、库气或五行生克链。个人合参不得宣称本命日主被当日某气生扶、泄耗或克制，只能说明已给关系标签可能对应的主观注意点。
+day_trigger.summary中的日干运势、地支五行和六气对应是三个并列的确定性事实。不得把日柱整体改写成某一种五行，也不得把地支与六气的“对应”改写成地支自身具有某种六气属性。
+calculation.industry_symbols只提供五行与行业的传统取象归类及其本次出现依据。必须说明这些气机对相关行业可能形成的象征性关注、节奏或约束，但不得引入行业实时行情，不得预测行业涨跌或把取象写成投资推荐；未列入industry_symbols的行业不得自行补造。
+按“## 年纲、## 客主加临、## 日辰触发、## 行业影响、## 个人合参、## 制衡动作”组织答案；没有个人资料时可以省略“个人合参”。不得用行情上涨下跌、行业表现或个股结果证明运气关系。篇幅按实际关系自然展开，不设置固定字数。
+""".strip()
+    return common + """
+
+当前任务是“观心·解卦”。用户在起卦前确定的问题位于calculation.question，question_preset只说明问题来源。必须针对实际问题作答；无题观心时不得猜测用户没有说出的事项。
+question_scope是本次问题的产品边界。trade预设专指股票交易中的参与条件、机会、阻碍和风险，不是商业合作、融资、借贷或寻找资金方；除非用户问题明确写出这些背景，否则不得擅自补入。
+纳甲、卦宫、世应、六亲、六神、月建日辰、旬空、伏神、动变和冲合关系已经由确定性程序给出。只能解释这些结果，不得自行改排盘、补用神或用模型记忆重算。六神只作辅助，任何单项都不能独立决定结论。
+六亲是关系类别，不是现实人物或资金来源的一一映射。必须使用knowledge中的六亲、旬空、动变和六神边界；不得把妻财直接写成现金或融资，把子孙写成资金提供方，把兄弟写成合作方，也不得由某一六神直接推出紧迫、欺骗或吉凶。
+除非calculation.question明确说明用户已经持仓、买入、卖出或正在管理仓位，否则不得假定用户已经入场，不得使用“持仓、仓位、建仓、入场、持有、买入、卖出、止损、止盈”等措辞描述用户现状。可以只写尚待核对的参与条件、风险边界和决策倾向。
+除非问题明确涉及融资、借贷、合作或资源安排，否则不得制造外围资金、外围资源、资金进入、资源进入，也不得虚构资金或资源的来源、提供、注入、安排和路径。
+按“## 所问之答、## 卦象依据、## 动变与之卦、## 可验证之处”组织答案。先直接回应所问，再用白话解释本卦所示处境、世应与相关六亲、关键动爻和变爻，最后说明之卦趋向及一项可以由用户验证的动作。若证据相互冲突，应明确说明结论成立的条件，不以“吉、凶”二字替代推理。
+交易问题可以判断参与条件、内外阻碍、风险和决策倾向，但不得宣告具体股价、涨跌日期或替用户作无条件买卖决定。不得用旬空、填实、出空或干支日推算“未来几日”或某日应验；可验证动作必须是用户当下能核对的交易条件或自身判断，不能制造现实中不存在的合作方、承诺、资金或资源安排。心境问题聚焦念头、压力和盲点；无题观心只作一般卦象观照。篇幅随问题和动爻复杂度自然展开，不使用固定三句模板，也不得输出使用竖线分栏的Markdown表格。
+""".strip()
+
+
+def _validate_answer(
+    mode: str, answer: str, context: dict[str, Any] | None = None
+) -> None:
+    compact = "".join(answer.split())
+    if len(compact) < 60:
+        raise HeavenAgentError("问天模型返回内容过短，未形成有效解读。")
+    forbidden = ("必涨", "必跌", "保证上涨", "保证下跌", "无条件买入", "无条件卖出")
+    if any(term in answer for term in forbidden):
+        raise HeavenAgentError("问天模型返回了禁止的确定性行情断语。")
+    if mode == "fortune" and "%" in answer:
+        raise HeavenAgentError("解运结果错误引用了已排除的权重百分比。")
+    if mode == "trend":
+        market_narratives = (
+            "行业", "板块", "个股", "指数", "成交额", "涨停", "跌停",
+            "政策", "消费环境", "基本面", "资金面",
+        )
+        if any(term in answer for term in market_narratives):
+            raise HeavenAgentError("解势结果错误引入了卦象之外的现实市场叙事。")
+    if mode == "fortune":
+        if re.search(
+            r"(?:命局|个人本身).{0,16}(?:偏重|较重|过旺|过弱|身强|身弱|喜用神)",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果错误推断了输入中不存在的命局强弱。")
+        if re.search(
+            r"藏干|[子丑寅卯辰巳午未申酉戌亥](?:中|内)|[子丑寅卯辰巳午未申酉戌亥].{0,4}(?:含|藏)|(?:中|内)藏|余气|[辰戌丑未].{0,4}(?:火库|水库|金库|木库|土库|燥土|湿土)",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果使用了输入中未提供的藏干推断。")
+        if re.search(
+            r"木生火|火生土|土生金|金生水|水生木|木克土|土克水|水克火|火克金|金克木",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果自行扩展了输入中未提供的五行生克链。")
+        if re.search(
+            r"(?:本命)?日主.{0,32}(?:生扶|泄耗|受克|被克|得生|被生|偏强|偏弱)",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果把当日关系错误扩展成了本命强弱推断。")
+        if re.search(
+            r"(?:日柱)?[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]"
+            r".{0,8}(?:本身|自身)(?:就)?是[木火土金水]",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果错误地把整个日柱归成了单一五行。")
+        if re.search(
+            r"[子丑寅卯辰巳午未申酉戌亥](?:的|具有|带有).{0,8}"
+            r"(?:风木|君火|湿土|相火|燥金|寒水)(?:之)?(?:属性|性质)",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果把六气对应误写成了地支自身属性。")
+        calculation = (context or {}).get("calculation") or {}
+        if calculation.get("industry_symbols") and "行业影响" not in answer:
+            raise HeavenAgentError("解运结果遗漏了本次必答的行业影响。")
+        if re.search(
+            r"行业.{0,16}(?:必涨|必跌|必然上涨|必然下跌|确定领涨|确定领跌|投资推荐)",
+            answer,
+        ):
+            raise HeavenAgentError("解运结果把行业取象错误写成了行情预测或投资推荐。")
+        personal = calculation.get("personal") or {}
+        personal_today = personal.get("today_relative_to_natal_day_master") or {}
+        pillar_values = {
+            str(value)
+            for group in (calculation.get("pillars") or {}, personal_today.get("pillars") or {})
+            for value in group.values()
+            if value
+        }
+        mentioned_pillars = set(
+            re.findall(r"[甲乙丙丁戊己庚辛壬癸][子丑寅卯辰巳午未申酉戌亥]", answer)
+        )
+        if mentioned_pillars - pillar_values:
+            raise HeavenAgentError("解运结果补入了确定性输入中不存在的干支。")
+        month_pillar = str((calculation.get("pillars") or {}).get("month") or "")
+        month_branch = month_pillar[1:2]
+        mentioned_month_branches = set(
+            re.findall(r"([子丑寅卯辰巳午未申酉戌亥])月", answer)
+        )
+        if mentioned_month_branches - ({month_branch} if month_branch else set()):
+            raise HeavenAgentError("解运结果补入了当前月份之外的地支月。")
+        if personal:
+            relations = {
+                str(value)
+                for value in (personal_today.get("stem_relations") or {}).values()
+                if value
+            }
+            if "个人合参" not in answer and "本命日主" not in answer:
+                raise HeavenAgentError("解运结果遗漏了本次必答的个人合参。")
+            if relations and not any(relation in answer for relation in relations):
+                raise HeavenAgentError("解运结果未使用程序提供的当日关系标签。")
+    if mode != "heart":
+        return
+    calculation = (context or {}).get("calculation") or {}
+    question = str(calculation.get("question") or "")
+    if _contains_markdown_table(answer):
+        raise HeavenAgentError("解卦结果错误输出了Markdown表格。")
+    position_terms = (
+        "持仓", "仓位", "建仓", "入场", "持有", "买入", "卖出", "止损", "止盈",
+    )
+    if not any(term in question for term in position_terms) and any(
+        term in answer for term in position_terms
+    ):
+        raise HeavenAgentError("解卦结果擅自假定了用户的持仓或买卖状态。")
+    financing_terms = (
+        "融资", "借贷", "合作", "出资", "资金来源", "资金方", "投资人", "投资方",
+        "外部资金", "外围资金", "外部资源", "外围资源",
+    )
+    invented_scenarios = (
+        "融资", "借贷", "合作方", "资金提供方", "资金意向", "资金注入", "自有资金",
+        "外围资金", "外围资源", "资金进入", "资源进入",
+    )
+    invented_resource_path = re.search(
+        r"(?:资金|资源).{0,8}(?:来源|提供|注入|安排|路径)", answer
+    )
+    if not any(term in question for term in financing_terms) and (
+        any(term in answer for term in invented_scenarios) or invented_resource_path
+    ):
+        raise HeavenAgentError("解卦结果擅自补入了用户没有提出的融资或合作场景。")
+    timing_patterns = (
+        r"未来\s*[一二三四五六七八九十\d]+\s*(?:个)?(?:交易)?日",
+        r"[子丑寅卯辰巳午未申酉戌亥]{1,2}日(?:到来|来临|之前|之后|前后)",
+        r"(?:等待|等到|待).{0,16}(?:旬空|空亡).{0,16}(?:填实|出空)",
+    )
+    if any(re.search(pattern, answer) for pattern in timing_patterns):
+        raise HeavenAgentError("解卦结果错误使用旬空或干支推算了具体应期。")
+
+
+def _contains_markdown_table(answer: str) -> bool:
+    return bool(
+        re.search(r"(?m)^\s*\|", answer)
+        or re.search(r"(?m)^\s*:?-{3,}:?\s*\|", answer)
+        or re.search(r"(?m)\|\s*:?-{3,}:?\s*(?:\||$)", answer)
+    )

app/backend/features/heaven/engine.py

@@ -5,11 +5,10 @@ import math
 import sys
 from datetime import datetime
 from functools import lru_cache
-from pathlib import Path
 from typing import Any
 
+from backend.bootstrap.config import APP_DIR
 
-APP_DIR = Path(__file__).resolve().parent
 VENDOR_DIR = APP_DIR / "vendor"
 ICHING_DATA_FILE = APP_DIR / "data" / "iching_zh.json"
 if str(VENDOR_DIR) not in sys.path:
@@ -734,6 +733,7 @@ def hexagram_from_lines(values: list[int]) -> dict[str, Any]:
     return {
         "name": primary["name"],
         "text": primary["text"],
+        "tuan": primary.get("tuan") or "",
         "image": primary.get("image") or "",
         "inner_trigram": inner,
         "outer_trigram": outer,
@@ -742,6 +742,7 @@ def hexagram_from_lines(values: list[int]) -> dict[str, Any]:
         "transformed": {
             "name": transformed["name"],
             "text": transformed["text"],
+            "tuan": transformed.get("tuan") or "",
             "image": transformed.get("image") or "",
             "inner_trigram": transformed_inner,
             "outer_trigram": transformed_outer,

app/backend/features/heaven/http.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import json
+from http import HTTPStatus
+
+
+class HeavenHttpMixin:
+    def heaven_hexagram(self) -> None:
+        try:
+            body = self.read_json_body()
+            result = self.application_service.heaven_hexagram(body.get("lines"))
+            self.send_json({"ok": True, "hexagram": result})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+
+    def heaven_personal(self) -> None:
+        try:
+            body = self.read_json_body()
+            result = self.application_service.heaven_personal(body)
+            self.send_json({"ok": True, "personal": result})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+
+    def heaven_interpret(self) -> None:
+        try:
+            body = self.read_json_body()
+            result = self.application_service.heaven_interpret(body)
+            self.send_json({"ok": True, **result})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/heaven/knowledge.py

@@ -0,0 +1,387 @@
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from typing import Any
+
+from backend.bootstrap.config import APP_DIR
+
+
+KNOWLEDGE_FILE = APP_DIR / "data" / "heaven_knowledge.json"
+
+
+def prepare_heaven_context(mode: str, calculation: dict[str, Any]) -> dict[str, Any]:
+    """Build the only context shape that may cross the LLM boundary."""
+    if mode == "trend":
+        prepared = _prepare_trend(calculation)
+    elif mode == "fortune":
+        prepared = _prepare_fortune(calculation)
+    elif mode == "heart":
+        prepared = _prepare_heart(calculation)
+    else:
+        raise ValueError("不支持的问天知识模式。")
+    prepared["knowledge"] = retrieve_heaven_knowledge(mode, prepared)
+    return prepared
+
+
+def retrieve_heaven_knowledge(mode: str, context: dict[str, Any]) -> dict[str, Any]:
+    catalog = _knowledge_catalog()
+    source_ids: list[str]
+    records: list[dict[str, Any]]
+    if mode == "trend":
+        source_ids = ["zhouyi"]
+        records = _trend_records(catalog, context)
+    elif mode == "fortune":
+        source_ids = ["neijing"]
+        records = _fortune_records(catalog, context)
+    elif mode == "heart":
+        source_ids = ["zhouyi", "jingfang", "huozhulin", "zengshan"]
+        records = _heart_records(catalog, context)
+    else:
+        raise ValueError("不支持的问天知识模式。")
+    return {
+        "version": str(catalog.get("version") or ""),
+        "retrieval": "deterministic-keyed",
+        "sources": [
+            {"id": source_id, **dict(catalog["sources"][source_id])}
+            for source_id in source_ids
+        ],
+        "records": records,
+    }
+
+
+def _prepare_trend(context: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "mode": "trend",
+        "calculation": {
+            "data_trade_date": context.get("data_trade_date") or "",
+            "hexagram": context.get("hexagram") or {},
+            "movement": context.get("movement") or {},
+        },
+        "interpretation_contract": {
+            "required": ["明确卦势倾向", "主要矛盾", "实际动爻转折", "本卦到之卦的变化关系"],
+            "allowed": ["偏进或偏守", "先难后易或由盛转收", "结论有条件或存在分歧"],
+            "forbidden": ["原始行情旁证", "具体涨跌预测", "时间点预测", "无条件买卖指令", "泛化劝诫代替解卦"],
+        },
+    }
+
+
+def _prepare_fortune(context: dict[str, Any]) -> dict[str, Any]:
+    field = context.get("five_phase_field") or {}
+    framework = field.get("framework") or {}
+    relations = framework.get("relations") or {}
+    layers = {
+        str(item.get("id") or ""): item
+        for item in framework.get("layers") or []
+        if isinstance(item, dict)
+    }
+    six_qi = field.get("six_qi") or {}
+    movement = field.get("movement") or {}
+    pillars = field.get("pillars") or {}
+    personal = context.get("personal_profile") or {}
+    sector_catalog = {
+        str(group.get("element") or ""): [
+            str(item.get("name") or "").strip()
+            for item in group.get("industries") or []
+            if str(item.get("name") or "").strip()
+        ]
+        for group in field.get("sector_catalog") or []
+        if isinstance(group, dict)
+    }
+    industry_bases: dict[str, list[str]] = {}
+
+    def add_industry_basis(element: str, basis: str) -> None:
+        if element not in sector_catalog or not sector_catalog[element]:
+            return
+        industry_bases.setdefault(element, [])
+        if basis not in industry_bases[element]:
+            industry_bases[element].append(basis)
+
+    add_industry_basis(str(movement.get("phase") or ""), "中运")
+    for label, qi in (
+        ("司天", six_qi.get("sitian")),
+        ("在泉", six_qi.get("zaiquan")),
+        ("主气", six_qi.get("host_qi")),
+        ("客气", six_qi.get("guest_qi")),
+    ):
+        qi_text = str(qi or "")
+        add_industry_basis(qi_text[-1:] if qi_text else "", label)
+    day_master = personal.get("day_master") or {}
+    current = personal.get("current") or {}
+    personal_context = {}
+    if day_master:
+        current_ten_gods = current.get("ten_gods") or {}
+        personal_context = {
+            "natal_day_master": {
+                "stem": day_master.get("stem") or "",
+                "element": day_master.get("element") or "",
+            },
+            "today_relative_to_natal_day_master": {
+                "pillars": current.get("pillars") or {},
+                "stem_relations": {
+                    key: str((current_ten_gods.get(key) or {}).get("stem") or "")
+                    for key in ("year", "month", "day")
+                },
+            },
+        }
+    return {
+        "mode": "fortune",
+        "calculation": {
+            "calendar_date": context.get("calendar_date") or field.get("date") or "",
+            "lunar_date": field.get("lunar_date") or "",
+            "pillars": {
+                "year": pillars.get("year") or "",
+                "month": pillars.get("month") or "",
+                "day": pillars.get("day") or "",
+            },
+            "solar_terms": field.get("solar_terms") or {},
+            "year_movement": {
+                "phase": movement.get("phase") or "",
+                "tendency": movement.get("tendency") or "",
+                "label": movement.get("label") or "",
+            },
+            "annual_qi": {
+                "sitian": six_qi.get("sitian") or "",
+                "zaiquan": six_qi.get("zaiquan") or "",
+                "ruling": six_qi.get("ruling") or "",
+                "ruling_qi": six_qi.get("ruling_qi") or "",
+                "annual_pattern": relations.get("annual_pattern") or {},
+            },
+            "current_qi": {
+                "step": six_qi.get("step"),
+                "step_name": six_qi.get("step_name") or "",
+                "host_qi": six_qi.get("host_qi") or "",
+                "guest_qi": six_qi.get("guest_qi") or "",
+                "guest_host_relation": relations.get("guest_host") or {},
+                "alignment": relations.get("alignment") or six_qi.get("alignment") or "",
+            },
+            "day_trigger": {
+                "day_pillar": pillars.get("day") or "",
+                "summary": (layers.get("day") or {}).get("summary") or "",
+            },
+            "industry_symbols": [
+                {
+                    "element": element,
+                    "basis": bases,
+                    "industries": sector_catalog[element],
+                }
+                for element, bases in industry_bases.items()
+            ],
+            "personal": personal_context,
+        },
+        "excluded_from_interpretation": [
+            "五行权重与百分比",
+            "主导元素排序",
+            "权重生成的复合断语",
+            "预制情绪与交易行为结论",
+            "行业实时行情旁证",
+            "简化喜用神与强弱结论",
+        ],
+        "interpretation_contract": {
+            "required": ["年纲", "当前客主加临", "日辰触发", "行业影响", "个人合参（如有）", "制衡动作"],
+            "forbidden": [
+                "重新计算五行权重",
+                "把相生直接判吉",
+                "把相克直接判凶",
+                "用市场涨跌证明气场",
+                "把行业取象写成行业涨跌预测或投资推荐",
+                "把当日日柱误称为用户命局",
+                "推断未提供的命局强弱或喜用神",
+            ],
+        },
+    }
+
+
+def _prepare_heart(context: dict[str, Any]) -> dict[str, Any]:
+    preset = str(context.get("question_preset") or "custom")
+    if preset not in {"trade", "mind", "unthemed", "custom"}:
+        preset = "custom"
+    return {
+        "mode": "heart",
+        "calculation": {
+            "question": str(context.get("question") or "").strip(),
+            "question_preset": preset,
+            "question_scope": {
+                "trade": "股票交易中的参与条件、机会、阻碍与风险，不是融资或商业合作问题。",
+                "mind": "影响股票交易判断的情绪、执念或盲点。",
+                "unthemed": "不指定事项的一般观照。",
+                "custom": "只按用户实际写出的事项理解，不补写背景。",
+            }[preset],
+            "ritual": context.get("ritual") or {},
+            "hexagram": context.get("hexagram") or {},
+            "six_yao": context.get("six_yao") or {},
+        },
+        "interpretation_contract": {
+            "required": ["回应所问", "本卦处境", "世应与相关六亲", "关键动变", "之卦趋向", "可验证动作"],
+            "plain_language": "专业术语首次出现时立即用白话解释。",
+            "forbidden": [
+                "修改纳甲排盘",
+                "猜测未输入的问题",
+                "把股票交易改写成融资或合作问题",
+                "把六亲直接等同于现实人物或资金来源",
+                "单凭六神或空亡断吉凶",
+                "根据旬空填实或干支日期预测应期",
+                "具体股价和时间点预测",
+                "无条件买卖指令",
+            ],
+        },
+    }
+
+
+def _trend_records(catalog: dict[str, Any], context: dict[str, Any]) -> list[dict[str, Any]]:
+    hexagram = (context.get("calculation") or {}).get("hexagram") or {}
+    moving = [line for line in hexagram.get("lines") or [] if line.get("moving")]
+    method_key = "stable" if not moving else "single" if len(moving) == 1 else "multiple"
+    rules = catalog["trend"]["rules"]
+    records = [
+        {"id": "trend-method", "source": "product_method", "text": catalog["trend"]["method"]},
+        {"id": f"trend-moving-{method_key}", "source": "product_method", "text": rules[method_key]},
+        _hexagram_record("primary", hexagram),
+    ]
+    records.extend(_line_record(line) for line in moving)
+    transformed = hexagram.get("transformed") or {}
+    if transformed:
+        records.append(_hexagram_record("transformed", transformed))
+    return records
+
+
+def _fortune_records(catalog: dict[str, Any], context: dict[str, Any]) -> list[dict[str, Any]]:
+    calculation = context.get("calculation") or {}
+    movement = calculation.get("year_movement") or {}
+    annual_qi = calculation.get("annual_qi") or {}
+    current_qi = calculation.get("current_qi") or {}
+    knowledge = catalog["fortune"]
+    records = [
+        {"id": "fortune-principle", "source": "neijing", "text": knowledge["principle"]},
+    ]
+    if calculation.get("industry_symbols"):
+        records.append(
+            {
+                "id": "fortune-industry-boundary",
+                "source": "product_method",
+                "text": knowledge["industry_boundary"],
+            }
+        )
+    personal = calculation.get("personal") or {}
+    if personal:
+        records.append(
+            {
+                "id": "fortune-personal-boundary",
+                "source": "product_method",
+                "text": knowledge["personal_boundary"],
+            }
+        )
+        today = personal.get("today_relative_to_natal_day_master") or {}
+        relation_semantics = knowledge.get("personal_relations") or {}
+        for relation in dict.fromkeys((today.get("stem_relations") or {}).values()):
+            if relation in relation_semantics:
+                records.append(
+                    {
+                        "id": f"fortune-personal-{relation}",
+                        "source": "product_method",
+                        "subject": relation,
+                        "text": relation_semantics[relation],
+                    }
+                )
+    tendency = str(movement.get("tendency") or "")
+    if tendency in knowledge["movement"]:
+        records.append({"id": f"movement-{tendency}", "source": "neijing", "text": knowledge["movement"][tendency]})
+    for key in ("sitian", "zaiquan"):
+        qi = str(annual_qi.get(key) or "")
+        if qi in knowledge["qi"]:
+            records.append({"id": f"annual-{key}", "source": "neijing", "subject": qi, "text": knowledge["qi"][qi]})
+    for key in ("host_qi", "guest_qi"):
+        qi = str(current_qi.get(key) or "")
+        if qi in knowledge["qi"]:
+            records.append({"id": f"current-{key}", "source": "neijing", "subject": qi, "text": knowledge["qi"][qi]})
+    relation = current_qi.get("guest_host_relation") or {}
+    relation_type = str(relation.get("type") or "")
+    if relation_type in knowledge["relations"]:
+        records.append({"id": f"relation-{relation_type}", "source": "neijing", "subject": relation.get("label") or "", "text": knowledge["relations"][relation_type]})
+    records.append({"id": "day-trigger", "source": "neijing", "text": knowledge["day_trigger"]})
+    return records
+
+
+def _heart_records(catalog: dict[str, Any], context: dict[str, Any]) -> list[dict[str, Any]]:
+    calculation = context.get("calculation") or {}
+    hexagram = calculation.get("hexagram") or {}
+    six_yao = calculation.get("six_yao") or {}
+    preset = str(calculation.get("question_preset") or "custom")
+    heart = catalog["heart"]
+    records = [
+        {"id": "heart-focus", "source": "product_method", "text": heart["focus"].get(preset, heart["focus"]["custom"])},
+        {"id": "heart-evidence-order", "source": "product_method", "items": heart["evidence_order"]},
+        {"id": "heart-limits", "source": "product_method", "text": heart["limits"]},
+        {"id": "heart-self-response", "source": "jingfang", "text": heart["semantics"]["self_response"]},
+        {"id": "heart-calendar", "source": "zengshan", "text": heart["semantics"]["calendar"]},
+        {"id": "heart-movement", "source": "huozhulin", "text": heart["semantics"]["movement"]},
+        {"id": "heart-six-spirits", "source": "zengshan", "text": heart["semantics"]["six_spirits"]},
+        {"id": "heart-timing-boundary", "source": "product_method", "text": heart["semantics"]["timing_boundary"]},
+        _hexagram_record("primary", hexagram),
+    ]
+    relatives = {
+        str(line.get("relative") or "")
+        for line in six_yao.get("lines") or []
+        if line.get("relative")
+    }
+    for relative in sorted(relatives):
+        text = (heart["semantics"].get("relatives") or {}).get(relative)
+        if text:
+            records.append(
+                {
+                    "id": f"heart-relative-{relative}",
+                    "source": "huozhulin",
+                    "subject": relative,
+                    "text": text,
+                }
+            )
+    records.extend(_line_record(line) for line in hexagram.get("lines") or [] if line.get("moving"))
+    transformed = hexagram.get("transformed") or {}
+    if transformed:
+        records.append(_hexagram_record("transformed", transformed))
+    palace = six_yao.get("palace") or {}
+    records.append(
+        {
+            "id": "heart-palace",
+            "source": "jingfang",
+            "text": (
+                f"本卦归{palace.get('name') or '--'}、{palace.get('stage') or '--'}，"
+                f"世在{palace.get('self_position') or '--'}爻，应在{palace.get('response_position') or '--'}爻。"
+            ),
+        }
+    )
+    return records
+
+
+def _hexagram_record(kind: str, hexagram: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": f"zhouyi-{kind}",
+        "source": "zhouyi",
+        "kind": kind,
+        "name": hexagram.get("name") or "",
+        "inner_trigram": hexagram.get("inner_trigram") or "",
+        "outer_trigram": hexagram.get("outer_trigram") or "",
+        "text": hexagram.get("text") or "",
+        "tuan": hexagram.get("tuan") or "",
+        "image": hexagram.get("image") or "",
+    }
+
+
+def _line_record(line: dict[str, Any]) -> dict[str, Any]:
+    return {
+        "id": f"zhouyi-line-{line.get('position') or ''}",
+        "source": "zhouyi",
+        "position": line.get("position"),
+        "position_name": line.get("position_name") or "",
+        "line_name": line.get("line_name") or "",
+        "text": line.get("text") or "",
+        "image": line.get("image") or "",
+    }
+
+
+@lru_cache(maxsize=1)
+def _knowledge_catalog() -> dict[str, Any]:
+    payload = json.loads(KNOWLEDGE_FILE.read_text(encoding="utf-8"))
+    if not payload.get("version") or not isinstance(payload.get("sources"), dict):
+        raise ValueError("问天知识库格式不完整。")
+    return payload

app/backend/features/heaven/manual.py

@@ -0,0 +1,412 @@
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+from backend.bootstrap.config import validate_text
+from backend.data.providers.tushare_client import _sector_coverage_issue
+from backend.features.heaven.engine import _market_line_scores, _score_to_line
+
+
+class HeavenManualMixin:
+    @staticmethod
+    def _heaven_manual_schema(market_mode: str) -> dict[str, dict[str, Any]]:
+        intraday = market_mode == "intraday"
+        fields = {
+            "stock_amount_percentile": {"line": 1, "label": "成交额全市场分位", "unit": "%", "min": 0, "max": 100},
+            "stock_turnover_rate": {"line": 1, "label": "个股换手率", "unit": "%", "min": 0, "max": 100},
+            "stock_turnover_relative": {"line": 1, "label": "相对市场换手", "unit": "倍", "min": 0, "max": 20},
+            "stock_volume_activity_ratio": {"line": 1, "label": "同进度量能", "unit": "倍", "min": 0, "max": 20},
+            "stock_seal_amount_million": {"line": 1, "label": "封单金额", "unit": "万元", "min": 0, "max": 100000000},
+            "stock_open_times": {"line": 1, "label": "开板次数", "unit": "次", "min": 0, "max": 100, "integer": True},
+            "stock_change": {"line": 2, "label": "个股涨跌幅", "unit": "%", "min": -100, "max": 100},
+            "stock_streak": {"line": 2, "label": "连板高度", "unit": "板", "min": 0, "max": 100, "integer": True},
+            "stock_status": {"line": 2, "label": "个股状态", "type": "select", "options": ["普通", "涨停", "炸板", "跌停"]},
+            "sector_name": {"line": [3, 4], "label": "申万二级行业", "type": "text", "max_length": 50},
+            "sector_up_count": {"line": 3, "label": "行业上涨家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "sector_down_count": {"line": 3, "label": "行业下跌家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "sector_coverage": {"line": 3, "label": "成分行情覆盖率", "unit": "%", "min": 0, "max": 100},
+            "sector_relative_turnover": {"line": 3, "label": "行业相对市场换手", "unit": "倍", "min": 0, "max": 20},
+            "sector_member_equal_change": {"line": 3, "label": "成分等权涨跌幅", "unit": "%", "min": -100, "max": 100},
+            "sector_change": {"line": 4, "label": "申万官方涨跌幅", "unit": "%", "min": -100, "max": 100},
+            "sector_leading_pct": {"line": [3, 4], "label": "行业领涨股涨跌幅", "unit": "%", "min": -100, "max": 100},
+            "market_sentiment_score": {"line": 5, "label": "市场情绪温度", "unit": "分", "min": 0, "max": 100},
+            "market_seal_rate": {"line": 5, "label": "封板率", "unit": "%", "min": 0, "max": 100},
+            "market_amount_billion": {"line": 5, "label": "两市成交额", "unit": "亿元", "min": 0, "max": 10000000},
+            "market_recent_average_amount_billion": {"line": 5, "label": "近期平均成交额", "unit": "亿元", "min": 0, "max": 10000000},
+            "market_up_count": {"line": 5, "label": "上涨家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "market_down_count": {"line": 5, "label": "下跌家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "market_limit_up_count": {"line": 5, "label": "涨停家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "market_limit_down_count": {"line": 5, "label": "跌停家数", "unit": "家", "min": 0, "max": 10000, "integer": True},
+            "index_sh_change": {"line": 6, "label": "上证指数涨跌幅", "unit": "%", "min": -20, "max": 20},
+            "index_sz_change": {"line": 6, "label": "深证成指涨跌幅", "unit": "%", "min": -20, "max": 20},
+            "index_cy_change": {"line": 6, "label": "创业板指涨跌幅", "unit": "%", "min": -20, "max": 20},
+            "note": {"line": [], "label": "补录说明", "type": "text", "max_length": 200},
+        }
+        if intraday:
+            for key in ("stock_seal_amount_million", "stock_open_times"):
+                fields.pop(key)
+        else:
+            for key in ("stock_turnover_relative", "stock_volume_activity_ratio", "sector_relative_turnover"):
+                fields.pop(key)
+        return fields
+
+    @classmethod
+    def _validate_heaven_manual_data(
+        cls, raw: Any, market_mode: str
+    ) -> dict[str, Any]:
+        if raw in (None, ""):
+            return {}
+        if not isinstance(raw, dict):
+            raise ValueError("六爻补录数据格式不正确。")
+        schema = cls._heaven_manual_schema(market_mode)
+        unknown = set(raw) - set(schema)
+        if unknown:
+            raise ValueError(f"六爻补录包含未知字段：{next(iter(sorted(unknown)))}")
+        values: dict[str, Any] = {}
+        for key, value in raw.items():
+            if value is None or (isinstance(value, str) and not value.strip()):
+                continue
+            spec = schema[key]
+            if spec.get("type") == "text":
+                values[key] = validate_text(value, spec["label"], int(spec["max_length"]))
+                continue
+            if spec.get("type") == "select":
+                text = str(value).strip()
+                if text not in spec["options"]:
+                    raise ValueError(f"{spec['label']}不在允许范围内。")
+                values[key] = text
+                continue
+            try:
+                number = float(value)
+            except (TypeError, ValueError) as exc:
+                raise ValueError(f"{spec['label']}必须是数字。") from exc
+            if number < float(spec["min"]) or number > float(spec["max"]):
+                raise ValueError(
+                    f"{spec['label']}应在 {spec['min']} 至 {spec['max']} 之间。"
+                )
+            values[key] = int(number) if spec.get("integer") else number
+        return values
+
+    @staticmethod
+    def _apply_heaven_manual_data(
+        dashboard: dict[str, Any],
+        index_context: dict[str, Any],
+        sector: dict[str, Any] | None,
+        stock: dict[str, Any] | None,
+        manual_data: dict[str, Any],
+        market_mode: str,
+        trade_date: str,
+        stock_code: str,
+    ) -> tuple[dict[str, Any], dict[str, Any], dict[str, Any], dict[str, Any]]:
+        dashboard = copy.deepcopy(dashboard)
+        index_context = copy.deepcopy(index_context or {})
+        sector = copy.deepcopy(sector or {})
+        stock = copy.deepcopy(stock or {})
+        overview = dashboard.setdefault("overview", {})
+
+        stock_map = {
+            "stock_amount_percentile": "amount_percentile",
+            "stock_turnover_rate": "turnover_rate",
+            "stock_turnover_relative": "turnover_relative",
+            "stock_volume_activity_ratio": "volume_activity_ratio",
+            "stock_seal_amount_million": "seal_amount_million",
+            "stock_open_times": "open_times",
+            "stock_change": "change",
+            "stock_streak": "streak",
+            "stock_status": "status",
+        }
+        sector_map = {
+            "sector_name": "name",
+            "sector_up_count": "up_count",
+            "sector_down_count": "down_count",
+            "sector_coverage": "coverage",
+            "sector_relative_turnover": "relative_turnover",
+            "sector_member_equal_change": "member_equal_change",
+            "sector_change": "change",
+            "sector_leading_pct": "leading_pct",
+        }
+        overview_map = {
+            "market_sentiment_score": "sentiment_score",
+            "market_seal_rate": "seal_rate",
+            "market_amount_billion": "amount_billion",
+            "market_recent_average_amount_billion": "recent_average_amount_billion",
+            "market_up_count": "up_count",
+            "market_down_count": "down_count",
+            "market_limit_up_count": "limit_up_count",
+            "market_limit_down_count": "limit_down_count",
+        }
+        for manual_key, target in stock_map.items():
+            if manual_key in manual_data:
+                stock[target] = manual_data[manual_key]
+        for manual_key, target in sector_map.items():
+            if manual_key in manual_data:
+                sector[target] = manual_data[manual_key]
+        for manual_key, target in overview_map.items():
+            if manual_key in manual_data:
+                overview[target] = manual_data[manual_key]
+
+        if any(key.startswith("stock_") for key in manual_data):
+            stock.setdefault("code", stock_code)
+            stock.setdefault("name", stock_code or "--")
+            stock["_quantitative_mode"] = "intraday" if market_mode == "intraday" else "historical"
+            if market_mode == "intraday" and "stock_volume_activity_ratio" in manual_data:
+                stock["activity_source"] = "user_supplied"
+        if any(key.startswith("sector_") for key in manual_data):
+            sector["_quantitative_mode"] = "intraday" if market_mode == "intraday" else "historical"
+            sector.setdefault("taxonomy", "sw_l2")
+
+        index_keys = (
+            ("index_sh_change", "000001.SH", "上证指数"),
+            ("index_sz_change", "399001.SZ", "深证成指"),
+            ("index_cy_change", "399006.SZ", "创业板指"),
+        )
+        rows = {str(row.get("ts_code") or row.get("code") or ""): dict(row) for row in index_context.get("indices") or []}
+        for manual_key, code, name in index_keys:
+            if manual_key not in manual_data:
+                continue
+            row = rows.get(code, {"ts_code": code, "name": name})
+            row.update({"pct_chg": manual_data[manual_key], "trade_date": trade_date})
+            rows[code] = row
+        ordered_rows = [rows.get(code) for _, code, _ in index_keys]
+        if all(ordered_rows):
+            index_context["indices"] = ordered_rows
+            changes = [float(row.get("pct_chg") or 0) for row in ordered_rows]
+            aggregate = dict(index_context.get("aggregate") or {})
+            aggregate["average_pct_chg"] = sum(changes) / 3
+            index_context["aggregate"] = aggregate
+        return dashboard, index_context, sector, stock
+
+    @classmethod
+    def _heaven_line_checks(
+        cls,
+        trade_date: str,
+        dashboard: dict[str, Any],
+        recent_history: list[dict[str, Any]],
+        index_context: dict[str, Any],
+        sector: dict[str, Any],
+        stock: dict[str, Any],
+        market_mode: str,
+        manual_data: dict[str, Any],
+    ) -> list[dict[str, Any]]:
+        intraday = market_mode == "intraday"
+        closed = market_mode == "closed"
+        schema = cls._heaven_manual_schema(market_mode)
+        required = {
+            1: (["stock_amount_percentile", "stock_turnover_relative", "stock_volume_activity_ratio"] if intraday else ["stock_amount_percentile", "stock_turnover_rate", "stock_seal_amount_million", "stock_open_times"]),
+            2: ["stock_change", "stock_streak", "stock_status"],
+            3: (["sector_name", "sector_up_count", "sector_down_count", "sector_coverage", "sector_relative_turnover"] if intraday else ["sector_name", "sector_up_count", "sector_down_count", "sector_coverage", "sector_member_equal_change", "sector_leading_pct"]),
+            4: ["sector_name", "sector_change", "sector_leading_pct"],
+            5: ["market_sentiment_score", "market_seal_rate", "market_amount_billion", "market_recent_average_amount_billion", "market_up_count", "market_down_count", "market_limit_up_count", "market_limit_down_count"],
+            6: ["index_sh_change", "index_sz_change", "index_cy_change"],
+        }
+        names = {
+            1: ("初爻", "个股内核", "成交活跃、换手与量能"),
+            2: ("二爻", "个股外显", "涨跌、连板与状态"),
+            3: ("三爻", "行业内核", "行业宽度与成交活跃"),
+            4: ("四爻", "行业外显", "行业涨跌与领涨表现"),
+            5: ("五爻", "市场内核", "情绪、封板、成交与市场宽度"),
+            6: ("上爻", "指数外显", "三大指数当日涨跌"),
+        }
+
+        index_date = str(index_context.get("trade_date") or "").replace("-", "")
+        index_rows = list(index_context.get("indices") or [])
+        index_dates = {str(row.get("trade_date") or "").replace("-", "") for row in index_rows}
+        index_issues = []
+        if len(index_rows) < 3:
+            index_issues.append(f"三大指数仅取得 {len(index_rows)}/3 条行情")
+        elif index_date != trade_date or index_dates != {trade_date}:
+            actual_dates = "、".join(sorted(value for value in index_dates if value)) or "未知"
+            index_issues.append(f"指数实际日期为 {actual_dates}，目标交易日为 {trade_date}")
+        elif not index_context.get("precise"):
+            index_issues.append("三大指数行情未通过完整性校验")
+        elif intraday and not index_context.get("realtime"):
+            index_issues.append("盘中缺少可核验的实时指数行情")
+        elif not intraday and (index_context.get("realtime") or str(index_context.get("source") or "") != "tushare"):
+            index_issues.append("收盘或历史行情不是官方指数日线")
+
+        sector_date = str(sector.get("trade_date") or "").replace("-", "")
+        sector_coverage = float(sector.get("coverage") or 0)
+        sector_explained_count = int(
+            sector.get("explained_count")
+            if sector.get("explained_count") is not None
+            else sector.get("quote_count") or 0
+        )
+        sector_explained_coverage = float(
+            sector.get("explained_coverage")
+            if sector.get("explained_coverage") is not None
+            else sector_coverage
+        )
+        sector_coverage_issue = _sector_coverage_issue(
+            int(sector.get("member_count") or 0),
+            int(sector.get("quote_count") or 0),
+            sector_explained_coverage,
+            sector_explained_count,
+        )
+        sector_common = []
+        if not sector:
+            sector_common.append("未取得申万二级行业归属")
+        elif sector.get("taxonomy") != "sw_l2":
+            sector_common.append("行业分类不是申万二级")
+        elif sector_date != trade_date:
+            sector_common.append("行业行情日期与目标交易日不一致")
+        elif intraday and not sector.get("realtime"):
+            sector_common.append("盘中行业行情不是申万实时行情")
+        elif market_mode == "historical" and sector.get("realtime"):
+            sector_common.append("历史行业行情不能使用实时快照")
+        elif closed and sector.get("realtime") and not sector.get("finalized"):
+            sector_common.append("收盘行业实时行情尚未形成15:00最终快照")
+        sector_inner = list(sector_common)
+        sector_outer = list(sector_common)
+        if not sector.get("inner_precise", sector.get("precise")):
+            sector_inner.append(str(sector.get("inner_error") or sector.get("error") or "行业内核数据未通过校验"))
+        if not sector.get("outer_precise", sector.get("precise")):
+            sector_outer.append(str(sector.get("outer_error") or sector.get("error") or "行业外显数据未通过校验"))
+        if sector and sector_coverage_issue and sector_coverage_issue not in sector_inner:
+            sector_inner.append(sector_coverage_issue)
+        if sector.get("realtime") and not sector.get("relative_turnover"):
+            sector_inner.append("缺少行业相对全市场换手活跃度")
+
+        stock_date = str(stock.get("trade_date") or "").replace("-", "")
+        stock_common = []
+        if not stock.get("code"):
+            stock_common.append("尚未载入有效个股")
+        elif stock_date != trade_date:
+            stock_common.append(f"个股实际日期为 {stock_date or '未知'}，目标交易日为 {trade_date}")
+        elif not stock.get("precise"):
+            stock_common.append("个股行情未通过完整性校验")
+        elif intraday and not stock.get("realtime"):
+            stock_common.append("盘中个股行情不是实时行情")
+        elif not intraday and (stock.get("realtime") or str(stock.get("data_source") or "") != "tushare"):
+            stock_common.append("收盘或历史个股行情不是官方日线")
+        stock_inner = list(stock_common)
+        if intraday and stock.get("turnover_source") in {None, "", "unavailable"}:
+            stock_inner.append("缺少可核验的实时换手率")
+        if intraday and stock.get("activity_source") in {None, "", "unavailable"}:
+            stock_inner.append("缺少同时间进度量能基准")
+
+        overview = dashboard.get("overview") or {}
+        market_key_map = {
+            "market_sentiment_score": "sentiment_score", "market_seal_rate": "seal_rate",
+            "market_amount_billion": "amount_billion", "market_recent_average_amount_billion": "recent_average_amount_billion",
+            "market_up_count": "up_count", "market_down_count": "down_count",
+            "market_limit_up_count": "limit_up_count", "market_limit_down_count": "limit_down_count",
+        }
+        market_issues = []
+        for manual_key, source_key in market_key_map.items():
+            if source_key == "recent_average_amount_billion":
+                history_values = [item.get("amount_billion") for item in recent_history[:-1] if item.get("amount_billion") is not None]
+                if source_key not in overview and not history_values:
+                    market_issues.append(f"缺少{schema[manual_key]['label']}")
+            elif source_key not in overview or overview.get(source_key) is None:
+                market_issues.append(f"缺少{schema[manual_key]['label']}")
+
+        automatic_issues = {
+            1: stock_inner, 2: stock_common, 3: sector_inner,
+            4: sector_outer, 5: market_issues, 6: index_issues,
+        }
+        limits = list(dashboard.get("limits") or [])
+        scores = _market_line_scores(dashboard, recent_history, index_context, sector, stock, limits)
+
+        value_map: dict[str, Any] = {
+            "stock_amount_percentile": stock.get("amount_percentile"),
+            "stock_turnover_rate": stock.get("turnover_rate"),
+            "stock_turnover_relative": stock.get("turnover_relative"),
+            "stock_volume_activity_ratio": stock.get("volume_activity_ratio"),
+            "stock_seal_amount_million": stock.get("seal_amount_million"),
+            "stock_open_times": stock.get("open_times"),
+            "stock_change": stock.get("change"), "stock_streak": stock.get("streak"),
+            "stock_status": stock.get("status"), "sector_name": sector.get("name"),
+            "sector_up_count": sector.get("up_count"), "sector_down_count": sector.get("down_count"),
+            "sector_coverage": sector.get("coverage"), "sector_relative_turnover": sector.get("relative_turnover"),
+            "sector_member_equal_change": sector.get("member_equal_change"),
+            "sector_change": sector.get("change"), "sector_leading_pct": sector.get("leading_pct"),
+            "market_sentiment_score": overview.get("sentiment_score"), "market_seal_rate": overview.get("seal_rate"),
+            "market_amount_billion": overview.get("amount_billion"),
+            "market_recent_average_amount_billion": overview.get("recent_average_amount_billion"),
+            "market_up_count": overview.get("up_count"), "market_down_count": overview.get("down_count"),
+            "market_limit_up_count": overview.get("limit_up_count"), "market_limit_down_count": overview.get("limit_down_count"),
+        }
+        history_values = [float(item.get("amount_billion")) for item in recent_history[:-1] if item.get("amount_billion") is not None]
+        if value_map["market_recent_average_amount_billion"] is None and history_values:
+            value_map["market_recent_average_amount_billion"] = sum(history_values) / len(history_values)
+        if value_map["stock_amount_percentile"] is None and not intraday:
+            amount = float(stock.get("amount_billion") or 0)
+            amounts = [float(item.get("amount_billion") or 0) for item in limits if item.get("amount_billion") is not None]
+            value_map["stock_amount_percentile"] = (
+                sum(item <= amount for item in amounts) / len(amounts) * 100 if amounts else None
+            )
+        row_by_code = {str(row.get("ts_code") or row.get("code") or ""): row for row in index_context.get("indices") or []}
+        value_map.update({
+            "index_sh_change": (row_by_code.get("000001.SH") or {}).get("pct_chg"),
+            "index_sz_change": (row_by_code.get("399001.SZ") or {}).get("pct_chg"),
+            "index_cy_change": (row_by_code.get("399006.SZ") or {}).get("pct_chg"),
+        })
+
+        def missing_value(key: str) -> bool:
+            value = value_map.get(key)
+            return value is None or (isinstance(value, str) and not value.strip())
+
+        invalid_fields = {
+            line_number: {key for key in keys if missing_value(key)}
+            for line_number, keys in required.items()
+        }
+        if stock_common:
+            invalid_fields[1].update(required[1])
+            invalid_fields[2].update(required[2])
+        else:
+            if intraday and stock.get("turnover_source") in {None, "", "unavailable"}:
+                invalid_fields[1].add("stock_turnover_relative")
+            if intraday and stock.get("activity_source") in {None, "", "unavailable"}:
+                invalid_fields[1].add("stock_volume_activity_ratio")
+
+        if sector_common:
+            invalid_fields[3].update(required[3])
+            invalid_fields[4].update(required[4])
+        else:
+            if not sector.get("inner_precise", sector.get("precise")) or sector_coverage_issue:
+                invalid_fields[3].update(key for key in required[3] if key != "sector_name")
+            if sector.get("realtime") and not sector.get("relative_turnover"):
+                invalid_fields[3].add("sector_relative_turnover")
+            # The official SW index supplies only the sector's external change. A valid
+            # membership name and member-stock leader remain usable when that quote fails.
+            if not sector.get("outer_precise", sector.get("precise")):
+                invalid_fields[4].add("sector_change")
+
+        if index_issues:
+            invalid_fields[6].update(required[6])
+
+        checks = []
+        for line_number in range(1, 7):
+            manual_keys = [key for key in required[line_number] if key in manual_data]
+            unresolved_fields = [
+                key for key in required[line_number]
+                if key in invalid_fields[line_number] and key not in manual_data
+            ]
+            hard_missing_identity = line_number in {1, 2} and not stock.get("code")
+            passed = not hard_missing_identity and not unresolved_fields
+            status = "manual" if passed and manual_keys else "passed" if passed else "failed"
+            reasons = [] if passed else [
+                *( ["请先输入并载入股票代码或名称"] if hard_missing_identity else automatic_issues[line_number] ),
+                *( ["需补充：" + "、".join(schema[key]["label"] for key in unresolved_fields)] if unresolved_fields else [] ),
+            ]
+            score = float(scores[line_number - 1]["score"])
+            position, layer, formula = names[line_number]
+            checks.append({
+                "line": line_number, "position": position, "layer": layer, "formula": formula,
+                "status": status, "passed": passed, "reasons": reasons,
+                "score": round(score, 3) if passed else None,
+                "line_value": _score_to_line(score) if passed else None,
+                "evidence": scores[line_number - 1]["evidence"] if passed else [],
+                "fields": [
+                    {
+                        "key": key, "label": schema[key]["label"], "unit": schema[key].get("unit", ""),
+                        "type": schema[key].get("type", "number"), "options": schema[key].get("options", []),
+                        "value": value_map.get(key), "manual": key in manual_data,
+                        "required": True, "min": schema[key].get("min"), "max": schema[key].get("max"),
+                        "integer": bool(schema[key].get("integer")),
+                    }
+                    for key in required[line_number]
+                ],
+            })
+        return checks

app/backend/features/heaven/market_context.py

@@ -0,0 +1,338 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.bootstrap.config import (
+    normalize_date,
+    tushare_code,
+    validate_stock_code,
+    validate_text,
+)
+from backend.data.providers.tushare_client import TushareError
+
+
+class HeavenMarketContextMixin:
+    def _resolve_heaven_stock_code(self, query: str) -> str:
+        raw = validate_text(query, "股票代码或名称", 30, required=True)
+        code_match = re.fullmatch(r"(\d{6})(?:\.(?:SH|SZ|BJ))?", raw.upper())
+        if code_match:
+            return validate_stock_code(code_match.group(1))
+
+        candidates = self.database.search_stock_master(raw)
+        exact = [item for item in candidates if str(item.get("name") or "").casefold() == raw.casefold()]
+        if not exact and self.configured:
+            try:
+                rows = self._tushare_client().query(
+                    "stock_basic",
+                    {"name": raw, "list_status": "L"},
+                    "ts_code,symbol,name,industry,market,list_date",
+                )
+            except TushareError:
+                rows = []
+            if rows:
+                self.database.upsert_stock_master(rows)
+                candidates = self.database.search_stock_master(raw)
+                exact = [
+                    item
+                    for item in candidates
+                    if str(item.get("name") or "").casefold() == raw.casefold()
+                ]
+
+        matches = exact or candidates
+        if len(matches) == 1:
+            return validate_stock_code(str(matches[0].get("code") or ""))
+        if len(matches) > 1:
+            choices = "、".join(
+                f"{item.get('name') or '--'}（{item.get('code') or '--'}）"
+                for item in matches[:5]
+            )
+            raise ValueError(f"匹配到多只股票：{choices}。请输入六位股票代码。")
+        raise ValueError(f"未找到股票“{raw}”，请检查名称或输入六位股票代码。")
+
+    def _heaven_stock_context(
+        self,
+        stock_code: str,
+        trade_date: str,
+        dashboard: dict[str, Any],
+        market_mode: str,
+    ) -> dict[str, Any]:
+        """Return the only stock contract accepted by heaven trend."""
+        pool_row = next(
+            (
+                dict(row) for key in ("limits", "broken", "down_limits")
+                for row in dashboard.get(key) or []
+                if str(row.get("code") or "") == stock_code
+            ),
+            {},
+        )
+        if market_mode == "intraday":
+            if self.configured:
+                try:
+                    quote = self._tushare_client().realtime_stock_quote(
+                        tushare_code(stock_code),
+                        trade_date,
+                    )
+                    return {
+                        **quote,
+                        "status": pool_row.get("status") or "普通",
+                        "seal_amount_million": pool_row.get("seal_amount_million") or 0,
+                        "open_times": pool_row.get("open_times") or 0,
+                        "streak": pool_row.get("streak") or 0,
+                        "precise": True,
+                    }
+                except TushareError:
+                    pass
+            if pool_row:
+                return {
+                    **pool_row,
+                    "data_source": "dashboard_rt" if dashboard.get("meta", {}).get("realtime") else "dashboard",
+                    "trade_date": trade_date,
+                    "realtime": bool(dashboard.get("meta", {}).get("realtime")),
+                    "precise": False,
+                }
+            return {
+                "code": stock_code,
+                "name": "--",
+                "sector": "其他",
+                "trade_date": trade_date,
+                "realtime": False,
+                "precise": False,
+            }
+
+        detail = self.get_stock_detail(stock_code, trade_date, force=True)
+        detail_meta = detail.get("meta") or {}
+        stock = detail.get("stock") or {}
+        resolved_date = normalize_date(str(detail_meta.get("trade_date") or trade_date))
+        source = str(detail_meta.get("source") or "")
+        return {
+            "code": stock_code,
+            "name": stock.get("name") or pool_row.get("name") or "--",
+            "sector": stock.get("industry") or pool_row.get("sector") or "其他",
+            "status": pool_row.get("status") or "普通",
+            "change": stock.get("change") or 0,
+            "turnover_rate": stock.get("turnover_rate") or 0,
+            "amount_billion": stock.get("amount_billion") or 0,
+            "seal_amount_million": pool_row.get("seal_amount_million") or 0,
+            "open_times": pool_row.get("open_times") or 0,
+            "streak": pool_row.get("streak") or 0,
+            "data_source": source,
+            "trade_date": resolved_date,
+            "realtime": False,
+            "precise": source == "tushare" and resolved_date == trade_date,
+        }
+
+    def _heaven_index_context(
+        self,
+        trade_date: str,
+        dashboard: dict[str, Any],
+        market_mode: str = "historical",
+    ) -> dict[str, Any]:
+        cached = self.database.get_data_snapshot("heaven_indices", trade_date)
+        cached_valid = False
+        if cached:
+            cached_rows = list(cached.get("indices") or [])
+            cached_dates = {
+                str(row.get("trade_date") or "").replace("-", "")
+                for row in cached_rows
+            }
+            cached_valid = (
+                len(cached_rows) == 3
+                and cached_dates == {trade_date}
+                and bool(cached.get("precise"))
+                and not cached.get("realtime")
+                and str(cached.get("source") or "") == "tushare"
+                and int(cached.get("schema_version") or 0) >= 3
+            )
+        if market_mode != "intraday" and cached_valid:
+            return cached
+
+        if not self.configured:
+            error = "Tushare Token 未配置"
+        else:
+            try:
+                client = self._tushare_client()
+                if market_mode == "intraday":
+                    payload = self._aggregate_index_context(trade_date)
+                    payload["schema_version"] = 3
+                    return payload
+                payload = client.market_indices(trade_date)
+                payload["schema_version"] = 3
+                if market_mode == "closed":
+                    payload["finalized"] = True
+                self.database.save_data_snapshot(
+                    "heaven_indices",
+                    trade_date,
+                    str(payload.get("source") or "tushare"),
+                    payload,
+                )
+                return payload
+            except Exception as exc:
+                error = str(exc)
+        overview = dashboard.get("overview") or {}
+        up_count = float(overview.get("up_count") or 0)
+        down_count = float(overview.get("down_count") or 0)
+        breadth = (up_count - down_count) / max(up_count + down_count, 1)
+        return {
+            "source": "market_breadth_proxy",
+            "trade_date": trade_date,
+            "realtime": False,
+            "precise": False,
+            "schema_version": 3,
+            "notice": f"指数数据不可用，当前以市场宽度代理：{error}",
+            "indices": [],
+            "aggregate": {
+                "average_pct_chg": round(breadth * 2.5, 3),
+                "average_return_5d": 0,
+                "average_return_20d": 0,
+            },
+        }
+
+    def _aggregate_index_context(
+        self,
+        trade_date: str,
+        tushare_error: str = "",
+    ) -> dict[str, Any]:
+        quotes = self.realtime_aggregator.tencent_indices()
+        epochs = [int(item.get("quote_time_epoch") or 0) for item in quotes]
+        quote_dates = {
+            datetime.fromtimestamp(epoch).astimezone().strftime("%Y%m%d")
+            for epoch in epochs if epoch
+        }
+        if len(quotes) != 3 or quote_dates != {trade_date}:
+            raise ValueError("腾讯三大指数日期与目标交易日不一致")
+        now = datetime.now().astimezone()
+        max_skew = 120 if now.hour >= 15 else 15
+        if max(epochs) - min(epochs) > max_skew:
+            raise ValueError(f"腾讯三大指数时间差超过{max_skew}秒")
+
+        code_map = {
+            "000001": "000001.SH",
+            "399001": "399001.SZ",
+            "399006": "399006.SZ",
+        }
+        client = self._tushare_client()
+        indices = []
+        start_date = (
+            datetime.strptime(trade_date, "%Y%m%d") - timedelta(days=20)
+        ).strftime("%Y%m%d")
+        for quote in quotes:
+            ts_code = code_map[str(quote.get("code") or "")]
+            history = client.query(
+                "index_daily",
+                {"ts_code": ts_code, "start_date": start_date, "end_date": trade_date},
+                "ts_code,trade_date,close,pct_chg",
+            )
+            history.sort(key=lambda item: str(item.get("trade_date") or ""))
+            completed_closes = [
+                float(item.get("close") or 0)
+                for item in history
+                if str(item.get("trade_date") or "") < trade_date
+                and float(item.get("close") or 0) > 0
+            ]
+            close_5d = (
+                completed_closes[-5]
+                if len(completed_closes) >= 5
+                else completed_closes[0] if completed_closes else 0
+            )
+            close = float(quote.get("price") or 0)
+            indices.append(
+                {
+                    "ts_code": ts_code,
+                    "name": quote.get("name") or ts_code,
+                    "trade_date": trade_date,
+                    "close": close,
+                    "pct_chg": round(float(quote.get("change") or 0), 3),
+                    "return_5d": round((close / close_5d - 1) * 100, 3) if close_5d else 0,
+                    "return_20d": 0,
+                    "amount_billion": float(quote.get("amount_billion") or 0),
+                    "quote_time": quote.get("quote_time") or "",
+                }
+            )
+        return {
+            "trade_date": trade_date,
+            "source": "+".join(
+                sorted({str(item.get("source") or "web_quote") for item in quotes})
+                + ["tushare_index_daily"]
+            ),
+            "realtime": True,
+            "precise": True,
+            "indices": indices,
+            "aggregate": {
+                "average_pct_chg": round(
+                    sum(item["pct_chg"] for item in indices) / len(indices), 3
+                ),
+                "average_return_5d": round(
+                    sum(item["return_5d"] for item in indices) / len(indices), 3
+                ),
+                "average_return_20d": 0,
+            },
+            "quote_time_skew_seconds": max(epochs) - min(epochs),
+            "notice": (
+                "指数实时行情来自腾讯行情，5日趋势来自Tushare历史指数。"
+                + (f" Tushare实时指数未使用：{tushare_error}" if tushare_error else "")
+            ),
+        }
+
+    def _heaven_sector_context(
+        self,
+        identifier: str,
+        trade_date: str,
+        market_mode: str = "historical",
+    ) -> dict[str, Any] | None:
+        """Return the Shenwan L2 sector context for heaven trend.
+
+        观势行业层只使用申万二级行业。外显盘中使用 rt_sw_k、历史使用
+        sw_daily；内核独立使用目标日期成分股行情聚合。收盘过渡期在
+        sw_daily 入库前接受同日15:00后的 rt_sw_k 收盘快照。
+        """
+        cache_key = f"{trade_date}:{identifier.strip().lower()}"
+        cached = self.database.get_data_snapshot("heaven_sector", cache_key)
+        cached_date = str((cached or {}).get("trade_date") or "").replace("-", "")
+        cached_valid = bool(
+            cached
+            and cached_date == trade_date
+            and cached.get("taxonomy") == "sw_l2"
+            and cached.get("inner_precise", cached.get("precise"))
+            and cached.get("outer_precise", cached.get("precise"))
+            and not cached.get("realtime")
+            and int(cached.get("schema_version") or 0) >= 6
+        )
+        if market_mode != "intraday" and cached_valid:
+            return cached
+        if not self.configured:
+            return None
+        try:
+            payload = self._tushare_client().sw_sector_snapshot(
+                tushare_code(identifier),
+                trade_date,
+                realtime_expected=market_mode == "intraday",
+                allow_realtime_close=market_mode == "closed",
+            )
+        except TushareError as exc:
+            if cached_valid:
+                return cached
+            return {
+                "name": "",
+                "code": "",
+                "taxonomy": "sw_l2",
+                "source": "tushare",
+                "trade_date": trade_date,
+                "realtime": market_mode == "intraday",
+                "precise": False,
+                "inner_precise": False,
+                "outer_precise": False,
+                "coverage": 0,
+                "member_count": 0,
+                "quote_count": 0,
+                "error": f"申万二级行业数据获取失败：{exc}",
+            }
+        if not payload.get("realtime") and payload.get("precise"):
+            self.database.save_data_snapshot(
+                "heaven_sector",
+                cache_key,
+                str(payload.get("source") or "tushare"),
+                payload,
+            )
+        return payload

app/backend/features/heaven/readings.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+import json
+import secrets
+from datetime import date
+from typing import Any
+
+from backend.bootstrap.config import normalize_date
+from backend.features.heaven.agent import (
+    HEAVEN_PROMPT_VERSIONS,
+    HeavenAgentError,
+    interpret_heaven,
+)
+from backend.features.heaven.engine import (
+    build_five_phase_field,
+    hexagram_from_lines,
+)
+from backend.features.heaven.knowledge import prepare_heaven_context
+from backend.features.heaven.six_yao import build_six_yao_chart
+from backend.features.market import MarketServiceMixin
+
+
+class HeavenReadingMixin:
+    def heaven_personal(self, payload: dict[str, Any]) -> dict[str, Any]:
+        trade_date = normalize_date(str(payload.get("trade_date") or date.today().isoformat()))
+        field = build_five_phase_field(
+            trade_date,
+            self.database.list_sector_phase_overrides(),
+        )
+        personal = self.account_personal_field(trade_date, field, public=True)
+        if not personal:
+            raise ValueError("请先在账号设置中保存个人命理资料。")
+        return personal
+
+    def heaven_hexagram(self, raw_lines: Any) -> dict[str, Any]:
+        if not isinstance(raw_lines, list):
+            raise ValueError("六爻起卦结果格式不正确。")
+        try:
+            lines = [int(value) for value in raw_lines]
+        except (TypeError, ValueError) as exc:
+            raise ValueError("六爻必须由六、七、八、九组成。") from exc
+        return hexagram_from_lines(lines)
+
+    def heaven_readings(
+        self, mode: str, context_date: str = "", limit: int = 100
+    ) -> dict[str, Any]:
+        mode = str(mode or "").strip()
+        if mode not in {"trend", "fortune", "heart"}:
+            raise ValueError("解读记录类型不正确。")
+        normalized_date = normalize_date(context_date) if context_date else ""
+        return {
+            "mode": mode,
+            "items": self.database.list_heaven_readings(
+                self.current_user_id, mode, normalized_date, limit
+            ),
+        }
+
+    @staticmethod
+    def _heaven_reading_identity(
+        mode: str, context_date: str, context: dict[str, Any]
+    ) -> tuple[str, str]:
+        display_date = MarketServiceMixin._display_compact_date(context_date)
+        if mode == "trend":
+            stock = (context.get("selected_focus") or {}).get("stock") or {}
+            code = str(stock.get("code") or "").strip()
+            name = str(stock.get("name") or "").strip()
+            hexagram = context.get("hexagram") or {}
+            transformed = hexagram.get("transformed") or {}
+            subject = " ".join(item for item in (code, name) if item) or "观势"
+            detail = f"{display_date} · {hexagram.get('name') or '--'} → {transformed.get('name') or '--'}"
+            return subject, detail
+        if mode == "fortune":
+            field = context.get("five_phase_field") or {}
+            pillars = field.get("pillars") or {}
+            dominant = (field.get("balance") or [{}])[0]
+            subject = f"{display_date} 观气"
+            detail = (
+                f"{pillars.get('year') or '--'}年 · {pillars.get('month') or '--'}月 · "
+                f"{pillars.get('day') or '--'}日 · {dominant.get('element') or '--'}气偏显"
+            )
+            return subject, detail
+        hexagram = context.get("hexagram") or {}
+        transformed = hexagram.get("transformed") or {}
+        question = str(context.get("question") or "").strip()
+        question_detail = f" · {question[:48]}" if question else ""
+        return (
+            f"{display_date} 观心",
+            f"{hexagram.get('name') or '--'} → {transformed.get('name') or '--'}{question_detail}",
+        )
+
+    def heaven_interpret(self, payload: dict[str, Any]) -> dict[str, Any]:
+        mode = str(payload.get("mode") or "").strip()
+        if mode not in {"trend", "fortune", "heart"}:
+            raise ValueError("问天解读模式不正确。")
+        trade_date = normalize_date(str(payload.get("trade_date") or date.today().isoformat()))
+        prompt_version = HEAVEN_PROMPT_VERSIONS[mode]
+        stale_fortune: dict[str, Any] | None = None
+        if mode == "fortune":
+            existing = self.database.latest_heaven_reading(
+                self.current_user_id, "fortune", trade_date
+            )
+            if self._legacy_truncated_heaven_reading(existing):
+                self.database.delete_heaven_reading(
+                    self.current_user_id, int(existing["id"])
+                )
+                existing = None
+            if existing and self.database.heaven_reading_interpretation_version(
+                self.current_user_id, int(existing["id"])
+            ) == prompt_version:
+                return {
+                    "answer": existing["answer"],
+                    "mode": mode,
+                    "compiler": "stored",
+                    "notice": "",
+                    "reading": existing,
+                    "reused": True,
+                }
+            stale_fortune = existing
+        if mode in {"trend", "fortune"}:
+            setup = self.heaven_setup(
+                trade_date,
+                str(payload.get("sector") or ""),
+                str(payload.get("stock_code") or ""),
+                payload.get("manual_data"),
+            )
+            if mode == "trend":
+                chart = setup["chart"]
+                if not chart.get("available"):
+                    issues = "；".join((chart.get("quality") or {}).get("issues") or [])
+                    raise ValueError(f"观势数据未通过六爻校验，暂不解势：{issues}")
+                hexagram_context = json.loads(json.dumps(chart["hexagram"], ensure_ascii=False))
+                for line in hexagram_context.get("lines", []):
+                    line.pop("evidence", None)
+                    line.pop("score", None)
+                    line.pop("talent", None)
+                    line.pop("layer", None)
+                    line.pop("role", None)
+                    if not line.get("moving"):
+                        line.pop("text", None)
+                        line.pop("image", None)
+                        line.pop("line_name", None)
+                context = {
+                    "data_trade_date": setup["trade_date"],
+                    "selected_focus": {
+                        "sector": chart.get("sector") or "",
+                        "stock": chart.get("stock") or {},
+                    },
+                    "hexagram": hexagram_context,
+                    "movement": chart.get("movement") or {},
+                }
+            else:
+                personal_profile = self.account_personal_field(
+                    setup["calendar_date"],
+                    setup["field"],
+                    public=False,
+                )
+                context = {
+                    "calendar_date": setup["calendar_date"],
+                    "five_phase_field": setup["field"],
+                    "personal_profile": personal_profile,
+                }
+                context_date = setup["calendar_date"]
+            if mode == "trend":
+                context_date = setup["trade_date"]
+        else:
+            question = str(payload.get("question") or "").strip()
+            if len(question) > 300:
+                raise ValueError("观心问题不能超过300个字符。")
+            question_preset = str(payload.get("question_preset") or "unthemed").strip()
+            if question_preset not in {"trade", "mind", "unthemed", "custom"}:
+                question_preset = "custom"
+            if not question:
+                question = "不设具体问题，只观此刻一念。"
+                question_preset = "unthemed"
+            raw_lines = payload.get("lines")
+            hexagram = self.heaven_hexagram(raw_lines)
+            context = {
+                "question": question,
+                "question_preset": question_preset,
+                "hexagram": hexagram,
+                "six_yao": build_six_yao_chart(
+                    [int(value) for value in raw_lines],
+                    str(payload.get("cast_at") or ""),
+                ),
+                "ritual": {
+                    "breathing": "用户已完成1秒准备与五轮吸3秒、顿2秒、呼4秒的静心呼吸。",
+                    "casting": "用户以三枚铜钱自初爻至上爻投掷六次。",
+                    "reflection": "用户已在看见卦象后察看第一念。",
+                },
+            }
+            context_date = trade_date
+        agent_context = prepare_heaven_context(mode, context)
+        agent_context["interpretation_version"] = prompt_version
+        result, compiler = self._call_heaven_agent(mode, agent_context)
+        subject, subject_detail = self._heaven_reading_identity(
+            mode, context_date, context
+        )
+        dedupe_key = (
+            f"fortune:{context_date}"
+            if mode == "fortune"
+            else f"{mode}:{context_date}:{secrets.token_urlsafe(12)}"
+        )
+        if stale_fortune:
+            self.database.delete_heaven_reading(
+                self.current_user_id, int(stale_fortune["id"])
+            )
+        reading = self.database.save_heaven_reading(
+            self.current_user_id,
+            mode,
+            context_date,
+            subject,
+            subject_detail,
+            str(result.get("answer") or ""),
+            agent_context,
+            dedupe_key,
+        )
+        return {
+            **result,
+            "mode": mode,
+            "compiler": compiler,
+            "notice": "当前智能服务繁忙，已自动切换备用服务。" if compiler == "fallback" else "",
+            "reading": reading,
+            "reused": False,
+        }
+
+    @staticmethod
+    def _legacy_truncated_heaven_reading(reading: dict[str, Any] | None) -> bool:
+        return bool(reading and str(reading.get("answer") or "").rstrip().endswith("……"))
+
+    def _call_heaven_agent(self, mode: str, context: dict[str, Any]) -> tuple[dict[str, Any], str]:
+        prompt_version = HEAVEN_PROMPT_VERSIONS[mode]
+        result = self.llm_gateway.call(
+            f"heaven_{mode}",
+            prompt_version,
+            lambda profile: interpret_heaven(
+                mode,
+                context,
+                profile.api_key,
+                profile.base_url,
+                profile.model,
+            ),
+            (HeavenAgentError,),
+        )
+        return result.value, result.role

app/backend/features/heaven/repository.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime
+from typing import Any
+
+
+class HeavenRepositoryMixin:
+    def list_sector_phase_overrides(self) -> dict[str, str]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT name, element FROM sector_phase_overrides ORDER BY updated_at DESC, name"
+            ).fetchall()
+        return {row["name"]: row["element"] for row in rows}
+
+    def save_sector_phase_override(self, name: str, element: str) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO sector_phase_overrides (name, element, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(name) DO UPDATE SET
+                    element = excluded.element,
+                    updated_at = excluded.updated_at
+                """,
+                (name, element, now),
+            )
+
+    def delete_sector_phase_override(self, name: str) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM sector_phase_overrides WHERE name = ?",
+                (name,),
+            )
+            return cursor.rowcount > 0
+
+    @staticmethod
+    def _heaven_reading_dict(row: sqlite3.Row | None) -> dict[str, Any] | None:
+        if not row:
+            return None
+        return {
+            "id": int(row["id"]),
+            "mode": str(row["mode"]),
+            "context_date": str(row["context_date"]),
+            "subject": str(row["subject"]),
+            "subject_detail": str(row["subject_detail"]),
+            "answer": str(row["answer"]),
+            "created_at": str(row["created_at"]),
+        }
+
+    def save_heaven_reading(
+        self,
+        user_id: int,
+        mode: str,
+        context_date: str,
+        subject: str,
+        subject_detail: str,
+        answer: str,
+        context_snapshot: dict[str, Any],
+        dedupe_key: str,
+    ) -> dict[str, Any]:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        snapshot_json = json.dumps(
+            context_snapshot, ensure_ascii=False, separators=(",", ":")
+        )
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO heaven_readings
+                    (user_id, mode, context_date, subject, subject_detail, answer,
+                     context_snapshot, dedupe_key, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(user_id, dedupe_key) DO NOTHING
+                """,
+                (
+                    int(user_id), mode, context_date, subject, subject_detail,
+                    answer, snapshot_json, dedupe_key, now,
+                ),
+            )
+            row = connection.execute(
+                """
+                SELECT id, mode, context_date, subject, subject_detail, answer, created_at
+                FROM heaven_readings WHERE user_id = ? AND dedupe_key = ?
+                """,
+                (int(user_id), dedupe_key),
+            ).fetchone()
+            connection.execute(
+                """
+                DELETE FROM heaven_readings
+                WHERE user_id = ? AND mode = ? AND id NOT IN (
+                    SELECT id FROM heaven_readings
+                    WHERE user_id = ? AND mode = ? ORDER BY id DESC LIMIT 100
+                )
+                """,
+                (int(user_id), mode, int(user_id), mode),
+            )
+        result = self._heaven_reading_dict(row)
+        if not result:
+            raise ValueError("解读记录保存失败。")
+        return result
+
+    def list_heaven_readings(
+        self,
+        user_id: int,
+        mode: str,
+        context_date: str = "",
+        limit: int = 100,
+    ) -> list[dict[str, Any]]:
+        clauses = ["user_id = ?", "mode = ?"]
+        parameters: list[Any] = [int(user_id), mode]
+        if context_date:
+            clauses.append("context_date = ?")
+            parameters.append(context_date)
+        parameters.append(max(1, min(100, int(limit))))
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT id, mode, context_date, subject, subject_detail, answer, created_at
+                FROM heaven_readings WHERE {' AND '.join(clauses)}
+                ORDER BY context_date DESC, id DESC LIMIT ?
+                """,
+                parameters,
+            ).fetchall()
+        return [self._heaven_reading_dict(row) for row in rows if row]
+
+    def latest_heaven_reading(
+        self, user_id: int, mode: str, context_date: str = ""
+    ) -> dict[str, Any] | None:
+        items = self.list_heaven_readings(user_id, mode, context_date, 1)
+        return items[0] if items else None
+
+    def heaven_reading_interpretation_version(
+        self, user_id: int, reading_id: int
+    ) -> str:
+        with self.connect() as connection:
+            row = connection.execute(
+                """
+                SELECT context_snapshot FROM heaven_readings
+                WHERE id = ? AND user_id = ?
+                """,
+                (int(reading_id), int(user_id)),
+            ).fetchone()
+        if not row:
+            return ""
+        try:
+            snapshot = json.loads(str(row["context_snapshot"] or "{}"))
+        except (TypeError, json.JSONDecodeError):
+            return ""
+        return str(snapshot.get("interpretation_version") or "")
+
+    def delete_heaven_reading(self, user_id: int, reading_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM heaven_readings WHERE id = ? AND user_id = ?",
+                (int(reading_id), int(user_id)),
+            )
+            return cursor.rowcount > 0

app/backend/features/heaven/routes.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import json
+import re
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs, unquote
+from backend.bootstrap.config import validate_text
+
+
+class HeavenRoutesMixin:
+    def _handle_heaven_get(self, parsed) -> bool:
+        if parsed.path == "/api/heaven/readings":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.heaven_readings(
+                        query.get("mode", [""])[0],
+                        query.get("context_date", [""])[0],
+                        int(query.get("limit", ["100"])[0]),
+                    )
+                )
+            except (TypeError, ValueError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/heaven/setup":
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            sector_name = query.get("sector", [""])[0]
+            stock_code = query.get("stock_code", [""])[0]
+            manual_data = None
+            manual_text = query.get("manual_data", [""])[0]
+            if manual_text:
+                try:
+                    manual_data = json.loads(manual_text)
+                except json.JSONDecodeError:
+                    self.send_json({"error": "六爻补录数据格式不正确。"}, HTTPStatus.BAD_REQUEST)
+                    return True
+            try:
+                self.send_json(
+                    self.application_service.heaven_setup(
+                        trade_date,
+                        sector_name,
+                        stock_code,
+                        manual_data,
+                    )
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False
+
+    def _handle_heaven_delete(self, parsed) -> bool:
+        heaven_reading_match = re.fullmatch(r"/api/heaven/readings/(\d+)", parsed.path)
+        if heaven_reading_match:
+            deleted = self.application_service.database.delete_heaven_reading(
+                self.application_service.current_user_id, int(heaven_reading_match.group(1))
+            )
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        sector_phase_match = re.fullmatch(r"/api/heaven/sector-phases/(.+)", parsed.path)
+        if sector_phase_match:
+            name = unquote(sector_phase_match.group(1)).strip()
+            deleted = self.application_service.database.delete_sector_phase_override(name)
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        return False
+
+    def save_sector_phase_override(self) -> None:
+        try:
+            body = self.read_json_body()
+            name = validate_text(body.get("name"), "行业或题材名称", 50, required=True)
+            element = str(body.get("element") or "").strip()
+            if element not in {"木", "火", "土", "金", "水"}:
+                raise ValueError("五行归类必须是木、火、土、金或水。")
+            self.application_service.database.save_sector_phase_override(name, element)
+            self.send_json({"ok": True})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/heaven/service.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from backend.features.heaven.manual import HeavenManualMixin
+from backend.features.heaven.market_context import HeavenMarketContextMixin
+from backend.features.heaven.readings import HeavenReadingMixin
+from backend.features.heaven.trend import HeavenTrendMixin
+
+
+class HeavenServiceMixin(
+    HeavenManualMixin,
+    HeavenMarketContextMixin,
+    HeavenTrendMixin,
+    HeavenReadingMixin,
+):
+    pass

app/backend/features/heaven/six_yao.py

@@ -0,0 +1,432 @@
+from __future__ import annotations
+
+from datetime import datetime, timedelta, timezone
+from functools import lru_cache
+from typing import Any
+
+from backend.features.heaven.engine import (
+    BRANCH_ELEMENT,
+    ELEMENT_CONTROLS,
+    ELEMENT_GENERATES,
+    LINE_POSITIONS,
+    Solar,
+)
+
+
+SHANGHAI = timezone(timedelta(hours=8), "Asia/Shanghai")
+
+TRIGRAM_BITS = {
+    "乾": (1, 1, 1),
+    "兑": (1, 1, 0),
+    "离": (1, 0, 1),
+    "震": (1, 0, 0),
+    "巽": (0, 1, 1),
+    "坎": (0, 1, 0),
+    "艮": (0, 0, 1),
+    "坤": (0, 0, 0),
+}
+BITS_TRIGRAM = {bits: name for name, bits in TRIGRAM_BITS.items()}
+PALACE_ELEMENT = {
+    "乾": "金",
+    "兑": "金",
+    "离": "火",
+    "震": "木",
+    "巽": "木",
+    "坎": "水",
+    "艮": "土",
+    "坤": "土",
+}
+
+# 京房纳甲通行表。每组均按初爻至三爻、四爻至上爻排列。
+NAJIA = {
+    "乾": {
+        "inner": (("甲", "子"), ("甲", "寅"), ("甲", "辰")),
+        "outer": (("壬", "午"), ("壬", "申"), ("壬", "戌")),
+    },
+    "坤": {
+        "inner": (("乙", "未"), ("乙", "巳"), ("乙", "卯")),
+        "outer": (("癸", "丑"), ("癸", "亥"), ("癸", "酉")),
+    },
+    "震": {
+        "inner": (("庚", "子"), ("庚", "寅"), ("庚", "辰")),
+        "outer": (("庚", "午"), ("庚", "申"), ("庚", "戌")),
+    },
+    "巽": {
+        "inner": (("辛", "丑"), ("辛", "亥"), ("辛", "酉")),
+        "outer": (("辛", "未"), ("辛", "巳"), ("辛", "卯")),
+    },
+    "坎": {
+        "inner": (("戊", "寅"), ("戊", "辰"), ("戊", "午")),
+        "outer": (("戊", "申"), ("戊", "戌"), ("戊", "子")),
+    },
+    "离": {
+        "inner": (("己", "卯"), ("己", "丑"), ("己", "亥")),
+        "outer": (("己", "酉"), ("己", "未"), ("己", "巳")),
+    },
+    "艮": {
+        "inner": (("丙", "辰"), ("丙", "午"), ("丙", "申")),
+        "outer": (("丙", "戌"), ("丙", "子"), ("丙", "寅")),
+    },
+    "兑": {
+        "inner": (("丁", "巳"), ("丁", "卯"), ("丁", "丑")),
+        "outer": (("丁", "亥"), ("丁", "酉"), ("丁", "未")),
+    },
+}
+
+PALACE_STAGES = (
+    ("本宫", (), 6),
+    ("一世", (0,), 1),
+    ("二世", (0, 1), 2),
+    ("三世", (0, 1, 2), 3),
+    ("四世", (0, 1, 2, 3), 4),
+    ("五世", (0, 1, 2, 3, 4), 5),
+    ("游魂", (0, 1, 2, 4), 4),
+    ("归魂", (4,), 3),
+)
+
+SIX_SPIRITS = ("青龙", "朱雀", "勾陈", "螣蛇", "白虎", "玄武")
+SPIRIT_START = {
+    "甲": 0,
+    "乙": 0,
+    "丙": 1,
+    "丁": 1,
+    "戊": 2,
+    "己": 3,
+    "庚": 4,
+    "辛": 4,
+    "壬": 5,
+    "癸": 5,
+}
+
+BRANCH_CLASH = {
+    "子": "午", "午": "子", "丑": "未", "未": "丑",
+    "寅": "申", "申": "寅", "卯": "酉", "酉": "卯",
+    "辰": "戌", "戌": "辰", "巳": "亥", "亥": "巳",
+}
+BRANCH_COMBINE = {
+    "子": "丑", "丑": "子", "寅": "亥", "亥": "寅",
+    "卯": "戌", "戌": "卯", "辰": "酉", "酉": "辰",
+    "巳": "申", "申": "巳", "午": "未", "未": "午",
+}
+BRANCH_HARM = {
+    "子": "未", "未": "子", "丑": "午", "午": "丑",
+    "寅": "巳", "巳": "寅", "卯": "辰", "辰": "卯",
+    "申": "亥", "亥": "申", "酉": "戌", "戌": "酉",
+}
+THREE_PUNISHMENTS = (frozenset("寅巳申"), frozenset("丑未戌"), frozenset("子卯"))
+SELF_PUNISHMENT = set("辰午酉亥")
+
+ADVANCE_PAIRS = {
+    ("亥", "子"), ("寅", "卯"), ("巳", "午"), ("申", "酉"),
+    ("丑", "辰"), ("辰", "未"), ("未", "戌"), ("戌", "丑"),
+}
+RETREAT_PAIRS = {(target, source) for source, target in ADVANCE_PAIRS}
+
+
+def build_six_yao_chart(values: list[int], cast_at: str = "") -> dict[str, Any]:
+    """Return a deterministic Jing Fang Na Jia chart for a six-coin result."""
+    if len(values) != 6 or any(value not in {6, 7, 8, 9} for value in values):
+        raise ValueError("六爻必须由六、七、八、九组成，且从初爻到上爻排列。")
+    observed_at = _parse_cast_at(cast_at)
+    solar = Solar.fromYmdHms(
+        observed_at.year,
+        observed_at.month,
+        observed_at.day,
+        observed_at.hour,
+        observed_at.minute,
+        observed_at.second,
+    )
+    lunar = solar.getLunar()
+    month_gz = lunar.getMonthInGanZhiExact()
+    day_gz = lunar.getDayInGanZhiExact2()
+    time_gz = lunar.getTimeInGanZhi()
+    void_branches = tuple(lunar.getDayXunKongExact2())
+    month_branch = month_gz[1]
+    day_stem, day_branch = day_gz[0], day_gz[1]
+
+    bits = tuple(1 if value % 2 else 0 for value in values)
+    transformed_values = tuple(7 if value == 6 else 8 if value == 9 else value for value in values)
+    transformed_bits = tuple(1 if value % 2 else 0 for value in transformed_values)
+    palace = _palace_map()[bits]
+    palace_element = PALACE_ELEMENT[palace["trigram"]]
+    self_position = int(palace["self_position"])
+    response_position = self_position + 3 if self_position <= 3 else self_position - 3
+    najia = _najia_for_bits(bits)
+    transformed_najia = _najia_for_bits(transformed_bits)
+    spirits = tuple(
+        SIX_SPIRITS[(SPIRIT_START[day_stem] + index) % 6] for index in range(6)
+    )
+
+    lines: list[dict[str, Any]] = []
+    for index, ((stem, branch), value) in enumerate(zip(najia, values)):
+        position = index + 1
+        element = BRANCH_ELEMENT[branch]
+        transformed_stem, transformed_branch = transformed_najia[index]
+        transformed_element = BRANCH_ELEMENT[transformed_branch]
+        line = {
+            "position": position,
+            "position_name": LINE_POSITIONS[index],
+            "value": value,
+            "yin_yang": "阳" if value % 2 else "阴",
+            "moving": value in {6, 9},
+            "stem": stem,
+            "branch": branch,
+            "element": element,
+            "relative": _six_relative(palace_element, element),
+            "spirit": spirits[index],
+            "role": "世" if position == self_position else "应" if position == response_position else "",
+            "void": branch in void_branches,
+            "month": _calendar_relation("月", month_branch, branch),
+            "day": _calendar_relation("日", day_branch, branch),
+        }
+        if line["moving"]:
+            line["transformation"] = {
+                "value": transformed_values[index],
+                "yin_yang": "阳" if transformed_values[index] % 2 else "阴",
+                "stem": transformed_stem,
+                "branch": transformed_branch,
+                "element": transformed_element,
+                "relative": _six_relative(palace_element, transformed_element),
+                "relation_to_origin": _transformation_relation(
+                    branch,
+                    element,
+                    transformed_branch,
+                    transformed_element,
+                ),
+            }
+        lines.append(line)
+
+    hidden = _hidden_spirits(palace["trigram"], palace_element, lines)
+    for item in hidden:
+        lines[item["position"] - 1].setdefault("hidden_spirits", []).append(item)
+
+    return {
+        "method": "京房纳甲·八宫世应",
+        "method_version": "xiaobai-six-yao-v1",
+        "sources": ["jingfang", "huozhulin", "zengshan"],
+        "cast_at": observed_at.isoformat(timespec="seconds"),
+        "timezone": "Asia/Shanghai",
+        "day_boundary": "晚子时仍按民用当日排日柱",
+        "calendar": {
+            "month": month_gz,
+            "month_branch": month_branch,
+            "day": day_gz,
+            "day_branch": day_branch,
+            "time": time_gz,
+            "day_void": "".join(void_branches),
+        },
+        "palace": {
+            "name": f"{palace['trigram']}宫",
+            "trigram": palace["trigram"],
+            "element": palace_element,
+            "stage": palace["stage"],
+            "self_position": self_position,
+            "response_position": response_position,
+        },
+        "lines": lines,
+        "hidden_spirits": hidden,
+        "branch_pattern": _hexagram_branch_pattern(lines),
+        "relationships": _significant_line_relationships(lines),
+    }
+
+
+def _parse_cast_at(raw: str) -> datetime:
+    value = str(raw or "").strip()
+    if not value:
+        return datetime.now(SHANGHAI)
+    try:
+        parsed = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    except ValueError as exc:
+        raise ValueError("起卦时间格式不正确。") from exc
+    if parsed.tzinfo is None:
+        parsed = parsed.replace(tzinfo=SHANGHAI)
+    return parsed.astimezone(SHANGHAI)
+
+
+@lru_cache(maxsize=1)
+def _palace_map() -> dict[tuple[int, ...], dict[str, Any]]:
+    result: dict[tuple[int, ...], dict[str, Any]] = {}
+    for trigram, trigram_bits in TRIGRAM_BITS.items():
+        pure = trigram_bits + trigram_bits
+        for stage, flipped, self_position in PALACE_STAGES:
+            bits = list(pure)
+            for index in flipped:
+                bits[index] = 1 - bits[index]
+            key = tuple(bits)
+            if key in result:
+                raise RuntimeError("八宫映射出现重复卦象。")
+            result[key] = {
+                "trigram": trigram,
+                "stage": stage,
+                "self_position": self_position,
+            }
+    if len(result) != 64:
+        raise RuntimeError("八宫映射未覆盖六十四卦。")
+    return result
+
+
+def _najia_for_bits(bits: tuple[int, ...]) -> tuple[tuple[str, str], ...]:
+    inner = BITS_TRIGRAM[bits[:3]]
+    outer = BITS_TRIGRAM[bits[3:]]
+    return tuple(NAJIA[inner]["inner"] + NAJIA[outer]["outer"])
+
+
+def _six_relative(palace_element: str, line_element: str) -> str:
+    if line_element == palace_element:
+        return "兄弟"
+    if ELEMENT_GENERATES[line_element] == palace_element:
+        return "父母"
+    if ELEMENT_GENERATES[palace_element] == line_element:
+        return "子孙"
+    if ELEMENT_CONTROLS[palace_element] == line_element:
+        return "妻财"
+    return "官鬼"
+
+
+def _calendar_relation(prefix: str, actor_branch: str, line_branch: str) -> dict[str, Any]:
+    actor_element = BRANCH_ELEMENT[actor_branch]
+    line_element = BRANCH_ELEMENT[line_branch]
+    labels = []
+    if actor_branch == line_branch:
+        labels.append(f"临{prefix}{'建' if prefix == '月' else '辰'}")
+    if BRANCH_CLASH[actor_branch] == line_branch:
+        labels.append("月破" if prefix == "月" else "日冲")
+    if BRANCH_COMBINE[actor_branch] == line_branch:
+        labels.append(f"{prefix}合")
+    if BRANCH_HARM[actor_branch] == line_branch:
+        labels.append(f"{prefix}害")
+    element_relation = _actor_element_relation(actor_element, line_element, prefix)
+    return {
+        "branch": actor_branch,
+        "element": actor_element,
+        "branch_relations": labels,
+        "element_relation": element_relation,
+    }
+
+
+def _actor_element_relation(actor: str, target: str, prefix: str) -> str:
+    if actor == target:
+        return f"{prefix}与爻同气"
+    if ELEMENT_GENERATES[actor] == target:
+        return f"{prefix}生爻"
+    if ELEMENT_CONTROLS[actor] == target:
+        return f"{prefix}克爻"
+    if ELEMENT_GENERATES[target] == actor:
+        return f"爻生{prefix}"
+    return f"爻克{prefix}"
+
+
+def _transformation_relation(
+    origin_branch: str,
+    origin_element: str,
+    target_branch: str,
+    target_element: str,
+) -> list[str]:
+    labels = []
+    if (origin_branch, target_branch) in ADVANCE_PAIRS:
+        labels.append("化进神")
+    elif (origin_branch, target_branch) in RETREAT_PAIRS:
+        labels.append("化退神")
+    if BRANCH_COMBINE[origin_branch] == target_branch:
+        labels.append("化合")
+    if BRANCH_CLASH[origin_branch] == target_branch:
+        labels.append("化冲")
+    if target_element == origin_element:
+        labels.append("变爻同气")
+    elif ELEMENT_GENERATES[target_element] == origin_element:
+        labels.append("回头生")
+    elif ELEMENT_CONTROLS[target_element] == origin_element:
+        labels.append("回头克")
+    elif ELEMENT_GENERATES[origin_element] == target_element:
+        labels.append("原爻生变")
+    else:
+        labels.append("原爻克变")
+    return labels
+
+
+def _hidden_spirits(
+    palace_trigram: str,
+    palace_element: str,
+    lines: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    present = {str(line["relative"]) for line in lines}
+    missing = {"父母", "兄弟", "子孙", "妻财", "官鬼"} - present
+    if not missing:
+        return []
+    pure_bits = TRIGRAM_BITS[palace_trigram] + TRIGRAM_BITS[palace_trigram]
+    result = []
+    for index, (stem, branch) in enumerate(_najia_for_bits(pure_bits)):
+        element = BRANCH_ELEMENT[branch]
+        relative = _six_relative(palace_element, element)
+        if relative not in missing:
+            continue
+        result.append(
+            {
+                "position": index + 1,
+                "position_name": LINE_POSITIONS[index],
+                "stem": stem,
+                "branch": branch,
+                "element": element,
+                "relative": relative,
+                "flying_relative": lines[index]["relative"],
+            }
+        )
+    return result
+
+
+def _hexagram_branch_pattern(lines: list[dict[str, Any]]) -> str:
+    pairs = ((0, 3), (1, 4), (2, 5))
+    if all(BRANCH_CLASH[lines[left]["branch"]] == lines[right]["branch"] for left, right in pairs):
+        return "六冲"
+    if all(BRANCH_COMBINE[lines[left]["branch"]] == lines[right]["branch"] for left, right in pairs):
+        return "六合"
+    return ""
+
+
+def _significant_line_relationships(lines: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    result = []
+    for left_index in range(6):
+        for right_index in range(left_index + 1, 6):
+            left = lines[left_index]
+            right = lines[right_index]
+            if not (left["moving"] or right["moving"] or left["role"] or right["role"]):
+                continue
+            labels = _branch_pair_relations(left["branch"], right["branch"])
+            element_relation = _pair_element_relation(left["element"], right["element"])
+            if not labels and element_relation == "同气":
+                continue
+            result.append(
+                {
+                    "positions": [left["position"], right["position"]],
+                    "lines": [left["position_name"], right["position_name"]],
+                    "branch_relations": labels,
+                    "element_relation": element_relation,
+                }
+            )
+    return result
+
+
+def _branch_pair_relations(left: str, right: str) -> list[str]:
+    labels = []
+    if BRANCH_COMBINE[left] == right:
+        labels.append("六合")
+    if BRANCH_CLASH[left] == right:
+        labels.append("六冲")
+    if BRANCH_HARM[left] == right:
+        labels.append("六害")
+    pair = frozenset((left, right))
+    if pair in THREE_PUNISHMENTS or (left == right and left in SELF_PUNISHMENT):
+        labels.append("相刑")
+    return labels
+
+
+def _pair_element_relation(left: str, right: str) -> str:
+    if left == right:
+        return "同气"
+    if ELEMENT_GENERATES[left] == right:
+        return "前者生后者"
+    if ELEMENT_GENERATES[right] == left:
+        return "后者生前者"
+    if ELEMENT_CONTROLS[left] == right:
+        return "前者克后者"
+    return "后者克前者"

app/backend/features/heaven/trend.py

@@ -0,0 +1,370 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from backend.bootstrap.config import normalize_date
+from backend.data.providers.tushare_client import _sector_coverage_issue
+from backend.features.heaven.agent import HEAVEN_PROMPT_VERSIONS
+from backend.features.heaven.engine import build_five_phase_field, build_market_hexagram
+
+
+class HeavenTrendMixin:
+    def heaven_setup(
+        self,
+        trade_date: str,
+        sector_name: str = "",
+        stock_code: str = "",
+        manual_data: dict[str, Any] | None = None,
+    ) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        dashboard = self.get_dashboard(normalized_date)
+        data_date = normalize_date(str(dashboard.get("meta", {}).get("trade_date") or normalized_date))
+        recent_history = self.database.snapshot_summaries(data_date, 10)
+        market_mode = self._heaven_market_mode(data_date, dashboard)
+        manual_data = self._validate_heaven_manual_data(manual_data, market_mode)
+        index_context = self._heaven_index_context(data_date, dashboard, market_mode)
+        external_stock = None
+        normalized_stock_code = ""
+        if stock_code.strip():
+            normalized_stock_code = self._resolve_heaven_stock_code(stock_code)
+            external_stock = self._heaven_stock_context(
+                normalized_stock_code,
+                data_date,
+                dashboard,
+                market_mode,
+            )
+        external_sector = None
+        if normalized_stock_code and self.configured:
+            external_sector = self._heaven_sector_context(
+                normalized_stock_code,
+                data_date,
+                market_mode,
+            )
+            if external_sector and external_stock:
+                external_stock["sector"] = external_sector.get("name") or external_stock.get("sector")
+        dashboard, index_context, external_sector, external_stock = self._apply_heaven_manual_data(
+            dashboard,
+            index_context,
+            external_sector,
+            external_stock,
+            manual_data,
+            market_mode,
+            data_date,
+            normalized_stock_code,
+        )
+        if external_sector and external_stock:
+            external_stock["sector"] = external_sector.get("name") or external_stock.get("sector")
+        sector_input = str((external_sector or {}).get("name") or sector_name.strip())
+        if not normalized_stock_code:
+            data_checks = []
+            chart = {
+                "available": False,
+                "selection_required": True,
+                "data_trade_date": data_date,
+                "sector": "",
+                "sector_code": "",
+                "sector_taxonomy": "",
+                "stock": {"code": "", "name": "", "status": ""},
+                "quality": {
+                    "status": "awaiting_selection",
+                    "issues": [],
+                    "principle": "",
+                    "sources": [],
+                },
+                "index_context": index_context,
+            }
+        else:
+            data_checks = self._heaven_line_checks(
+                data_date,
+                dashboard,
+                recent_history,
+                index_context,
+                external_sector or {},
+                external_stock or {},
+                market_mode,
+                manual_data,
+            )
+            quality_issues = [
+                f"{check['position']}·{check['layer']}：{'；'.join(check['reasons'])}"
+                for check in data_checks
+                if not check["passed"]
+            ]
+            if quality_issues:
+                chart = {
+                    "available": False,
+                    "selection_required": False,
+                    "data_trade_date": data_date,
+                    "sector": str((external_sector or {}).get("name") or sector_input or "--"),
+                    "sector_code": str((external_sector or {}).get("code") or ""),
+                    "sector_taxonomy": str((external_sector or {}).get("taxonomy") or ""),
+                    "stock": {
+                        "code": normalized_stock_code,
+                        "name": str((external_stock or {}).get("name") or "--"),
+                        "status": str((external_stock or {}).get("status") or ""),
+                    },
+                    "quality": {
+                        "status": "blocked",
+                        "issues": quality_issues,
+                        "principle": "六爻任一层缺少同日、同口径的有效数据，本系统不成卦。",
+                        "sources": self._heaven_trend_sources(
+                            data_date, index_context, external_sector, external_stock
+                        ),
+                    },
+                    "index_context": index_context,
+                }
+            else:
+                chart = build_market_hexagram(
+                    dashboard,
+                    recent_history,
+                    index_context,
+                    sector_input,
+                    normalized_stock_code,
+                    external_stock,
+                    external_sector,
+                )
+                chart["available"] = True
+                chart["selection_required"] = False
+                manual_active = any(check["status"] == "manual" for check in data_checks)
+                chart["quality"] = {
+                    "status": "manual" if manual_active else "verified",
+                    "issues": [],
+                    "principle": (
+                        "自动行情与用户补充数据均已通过同一套量化公式校验。"
+                        if manual_active
+                        else "指数、板块、个股均已通过同日同口径校验。"
+                    ),
+                    "sources": [
+                        *self._heaven_trend_sources(
+                            data_date, index_context, external_sector, external_stock
+                        ),
+                        *([{
+                            "lines": "补录爻位",
+                            "layer": "用户补充",
+                            "realtime": market_mode == "intraday",
+                            "detail": str(manual_data.get("note") or "量化数据经原公式重新计算"),
+                        }] if manual_active else []),
+                    ],
+                }
+        chart["data_checks"] = data_checks
+        chart["manual_data"] = manual_data
+        sector_phase_overrides = self.database.list_sector_phase_overrides()
+        field = build_five_phase_field(
+            normalized_date,
+            sector_phase_overrides,
+        )
+        personal_profile = self.account_personal_field(
+            normalized_date,
+            field,
+            public=True,
+        )
+        daily_fortune_reading = self._reusable_daily_fortune_reading(normalized_date)
+        return {
+            "trade_date": data_date,
+            "calendar_date": normalized_date,
+            "market_mode": market_mode,
+            "chart": chart,
+            "field": field,
+            "personal_profile": personal_profile,
+            "daily_fortune_reading": daily_fortune_reading,
+            "sector_phase_overrides": [
+                {"name": name, "element": element}
+                for name, element in sector_phase_overrides.items()
+            ],
+            "llm": {
+                "configured": self.llm_configured,
+                "model": self.llm_primary_model if self.llm_configured else "",
+                "fallback_configured": self.llm_fallback_configured,
+                "fallback_model": self.llm_fallback_model if self.llm_fallback_configured else "",
+            },
+        }
+
+    def _reusable_daily_fortune_reading(
+        self, context_date: str
+    ) -> dict[str, Any] | None:
+        reading = self.database.latest_heaven_reading(
+            self.current_user_id, "fortune", context_date
+        )
+        if not reading or self._legacy_truncated_heaven_reading(reading):
+            return None
+        version = self.database.heaven_reading_interpretation_version(
+            self.current_user_id, int(reading["id"])
+        )
+        if version != HEAVEN_PROMPT_VERSIONS["fortune"]:
+            return None
+        return reading
+
+    @staticmethod
+    def _heaven_market_mode(
+        trade_date: str,
+        dashboard: dict[str, Any],
+        now: datetime | None = None,
+    ) -> str:
+        """区分盘中、今日收盘和历史，避免把 rt_k 数据来源误当成交易状态。"""
+        now = now or datetime.now().astimezone()
+        if trade_date != now.strftime("%Y%m%d"):
+            return "historical"
+        meta = dashboard.get("meta") or {}
+        status = str(meta.get("market_status") or "").lower()
+        local_time = now.time().replace(tzinfo=None)
+        if status == "closed" or local_time > datetime.strptime("15:05", "%H:%M").time():
+            return "closed"
+        if status in {"trading", "auction", "pre_open"} or (
+            bool(meta.get("realtime"))
+            and local_time >= datetime.strptime("09:15", "%H:%M").time()
+        ):
+            return "intraday"
+        return "historical"
+
+    @staticmethod
+    def _heaven_trend_sources(
+        trade_date: str,
+        index_context: dict[str, Any],
+        sector: dict[str, Any] | None,
+        stock: dict[str, Any] | None,
+    ) -> list[dict[str, Any]]:
+        sector = sector or {}
+        stock = stock or {}
+        return [
+            {
+                "lines": "五爻、上爻",
+                "layer": "指数",
+                "source": index_context.get("source") or "unavailable",
+                "trade_date": index_context.get("trade_date") or "",
+                "realtime": bool(index_context.get("realtime")),
+                "detail": f"三大指数 {len(index_context.get('indices') or [])}/3",
+            },
+            {
+                "lines": "三爻、四爻",
+                "layer": "行业",
+                "source": sector.get("source") or "unavailable",
+                "trade_date": sector.get("trade_date") or "",
+                "realtime": bool(sector.get("realtime")),
+                "detail": (
+                    f"申万二级 {sector.get('name') or '--'} {sector.get('code') or '--'} "
+                    f"成分覆盖 {int(sector.get('quote_count') or 0)}/{int(sector.get('member_count') or 0)}"
+                ),
+            },
+            {
+                "lines": "初爻、二爻",
+                "layer": "个股",
+                "source": stock.get("data_source") or "unavailable",
+                "trade_date": stock.get("trade_date") or trade_date,
+                "realtime": bool(stock.get("realtime")),
+                "detail": (
+                    f"{stock.get('name') or '--'}；换手基准 "
+                    f"{stock.get('capital_trade_date') or '--'}"
+                ),
+            },
+        ]
+
+    @staticmethod
+    def _heaven_trend_quality_issues(
+        trade_date: str,
+        dashboard: dict[str, Any],
+        index_context: dict[str, Any],
+        sector: dict[str, Any] | None,
+        stock: dict[str, Any] | None,
+        market_mode: str = "historical",
+    ) -> list[str]:
+        issues: list[str] = []
+        intraday = market_mode == "intraday"
+        closed = market_mode == "closed"
+        if intraday:
+            meta = dashboard.get("meta") or {}
+            market_status = str(meta.get("market_status") or "")
+            now = datetime.now().astimezone()
+            try:
+                updated_at = datetime.fromisoformat(str(meta.get("updated_at") or ""))
+                if updated_at.tzinfo is None:
+                    updated_at = updated_at.replace(tzinfo=now.tzinfo)
+                snapshot_age = (now - updated_at.astimezone(now.tzinfo)).total_seconds()
+            except ValueError:
+                snapshot_age = float("inf")
+            if market_status in {"trading", "auction", "pre_open"} and snapshot_age > 120:
+                issues.append("主行情快照超过2分钟，请点击顶部刷新")
+        # 收盘后不再用 dashboard.market_status 作为阻断条件。盘后同步可能将
+        # rt_k 快照替换成同日盘后日线而不带该字段；六爻数据本身的日期、
+        # 完整性和来源校验已足以判断是否可以成卦。
+
+        index_date = str(index_context.get("trade_date") or "").replace("-", "")
+        index_rows = list(index_context.get("indices") or [])
+        index_row_dates = {
+            str(row.get("trade_date") or "").replace("-", "") for row in index_rows
+        }
+        if not index_context.get("precise") or len(index_rows) < 3:
+            issues.append("指数层缺少三大指数的有效行情")
+        elif index_date != trade_date or index_row_dates != {trade_date}:
+            issues.append("指数行情与目标交易日不一致")
+        elif intraday and not index_context.get("realtime"):
+            issues.append("盘中指数层缺少可核验的实时行情")
+        elif not intraday and (
+            index_context.get("realtime")
+            or str(index_context.get("source") or "") != "tushare"
+        ):
+            issues.append("历史/收盘指数层必须使用 Tushare 官方指数日线")
+
+        sector = sector or {}
+        sector_date = str(sector.get("trade_date") or "").replace("-", "")
+        sector_coverage = float(sector.get("coverage") or 0)
+        sector_explained_count = int(
+            sector.get("explained_count")
+            if sector.get("explained_count") is not None
+            else sector.get("quote_count") or 0
+        )
+        sector_explained_coverage = float(
+            sector.get("explained_coverage")
+            if sector.get("explained_coverage") is not None
+            else sector_coverage
+        )
+        sector_coverage_issue = _sector_coverage_issue(
+            int(sector.get("member_count") or 0),
+            int(sector.get("quote_count") or 0),
+            sector_explained_coverage,
+            sector_explained_count,
+        )
+        if not sector:
+            issues.append("行业层缺少申万二级行业归属")
+        elif sector.get("taxonomy") != "sw_l2":
+            issues.append("行业层必须使用申万二级行业分类")
+        elif sector_date != trade_date:
+            issues.append("行业行情与目标交易日不一致")
+        elif intraday and not sector.get("realtime"):
+            issues.append("盘中行业层缺少申万实时行情")
+        elif market_mode == "historical" and sector.get("realtime"):
+            issues.append("历史行业层不能使用实时快照")
+        elif closed and sector.get("realtime") and not sector.get("finalized"):
+            issues.append("收盘行业层缺少15:00最终快照")
+        if not sector.get("inner_precise", sector.get("precise")):
+            issues.append("行业内核缺少可核验的成分行情")
+        if not sector.get("outer_precise", sector.get("precise")):
+            issues.append("行业外显缺少申万官方行情")
+        if sector and sector_coverage_issue:
+            issues.append(sector_coverage_issue)
+        if sector.get("realtime") and not sector.get("relative_turnover"):
+            issues.append("行业内核缺少相对全市场换手活跃度")
+
+        stock = stock or {}
+        stock_date = str(stock.get("trade_date") or "").replace("-", "")
+        if not stock or not stock.get("code"):
+            issues.append("个股层尚未载入有效标的")
+        elif not stock.get("precise"):
+            issues.append("个股层缺少可核验的行情数据")
+        elif stock_date != trade_date:
+            issues.append("个股行情与目标交易日不一致")
+        elif intraday and not stock.get("realtime"):
+            issues.append("盘中个股层不是 rt_k 实时行情")
+        elif not intraday and (
+            stock.get("realtime")
+            or str(stock.get("data_source") or "") != "tushare"
+        ):
+            issues.append("历史/收盘个股层必须使用 Tushare 官方日线")
+        if intraday and stock and not stock.get("turnover_source"):
+            issues.append("个股内核缺少可核验的实时换手率")
+        elif intraday and stock.get("turnover_source") == "unavailable":
+            issues.append("个股内核缺少流通股本，无法计算实时换手率")
+        if intraday and stock.get("activity_source") == "unavailable":
+            issues.append("个股内核缺少近5日量能基准")
+        elif intraday and not stock.get("activity_source"):
+            issues.append("个股内核缺少同时间进度量能")
+        return issues

app/backend/features/market/charts.py

@@ -12,6 +12,7 @@ from datetime import datetime, time as dt_time, timedelta
 from threading import Lock
 from typing import Any, ClassVar
 
+from backend.bootstrap.config import tushare_code as _stock_market_code
 from backend.data.providers.ifind_client import IfindError, IfindHttpClient
 
 
@@ -475,16 +476,6 @@ def _ifind_point(row: dict[str, Any]) -> dict[str, Any] | None:
     }
 
 
-def _stock_market_code(code: str) -> str:
-    if code.startswith(("4", "8", "9")):
-        suffix = "BJ"
-    elif code.startswith("6"):
-        suffix = "SH"
-    else:
-        suffix = "SZ"
-    return f"{code}.{suffix}"
-
-
 def _number(value: Any) -> float:
     try:
         return float(value or 0)

app/backend/features/market/insights.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+# These imports preserve the historical module-level compatibility surface.
+import copy
+import json
+from datetime import datetime, time as dt_time, timedelta, timezone
+from statistics import median
+from typing import TYPE_CHECKING, Any, Callable
+
+from backend.data.numbers import non_nan_number as _number
+from backend.data.providers.ifind_client import IfindError, IfindHttpClient
+from backend.data.providers.tushare_client import TushareClient, TushareError
+from backend.features.market.insights_auction import (
+    MarketAuctionInsightsMixin as _MarketAuctionInsightsMixin,
+)
+from backend.features.market.insights_auction_data import (
+    MarketAuctionDataMixin as _MarketAuctionDataMixin,
+)
+from backend.features.market.insights_auction_scoring import (
+    MarketAuctionScoringMixin as _MarketAuctionScoringMixin,
+)
+from backend.features.market.insights_context import (
+    CHINA_TIMEZONE,
+    MarketInsightsContextMixin as _MarketInsightsContextMixin,
+    _display_date,
+)
+from backend.features.market.insights_popularity import (
+    MarketPopularityInsightsMixin as _MarketPopularityInsightsMixin,
+)
+from backend.features.market.insights_themes import (
+    MarketThemeInsightsMixin as _MarketThemeInsightsMixin,
+)
+
+
+class MarketInsightsService(
+    _MarketInsightsContextMixin,
+    _MarketAuctionScoringMixin,
+    _MarketAuctionDataMixin,
+    _MarketAuctionInsightsMixin,
+    _MarketThemeInsightsMixin,
+    _MarketPopularityInsightsMixin,
+):
+    """Read-only market features backed by Tushare and shared SQLite caches."""
+
+    pass

app/backend/features/market/insights_auction.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+
+import copy
+from datetime import datetime
+from statistics import median
+from typing import Any
+
+from backend.data.numbers import non_nan_number as _number
+from backend.data.providers.tushare_client import TushareError
+from backend.features.market.insights_context import _display_date
+
+
+class MarketAuctionInsightsMixin:
+    def auction_center(
+        self,
+        requested_date: str,
+        force: bool = False,
+        user_id: int = 0,
+    ) -> dict[str, Any]:
+        trade_date, previous_date = self._trade_context(requested_date)
+        session = self._auction_session(requested_date, trade_date)
+        phase = str(session["phase"])
+        ifind_ready = bool(self.ifind and self.ifind.configured)
+        live_dynamic = phase == "observing" and ifind_ready
+        use_ifind_snapshot = phase in {"observing", "selection", "finalized"} and ifind_ready
+        data_date = previous_date if phase == "pending" or (phase == "observing" and not live_dynamic) else trade_date
+        carried_forward = data_date != trade_date
+        cache_key = data_date
+        if not force and not live_dynamic:
+            cached = self.database.get_data_snapshot("auction_center_v6", cache_key)
+            if cached:
+                result = copy.deepcopy(cached)
+                result["meta"] = {
+                    **result.get("meta", {}),
+                    **session,
+                    "requested_date": _display_date(requested_date),
+                    "trade_date": _display_date(data_date),
+                    "carried_forward": carried_forward,
+                    "available": bool((result.get("summary") or {}).get("stock_count")),
+                    "cached": True,
+                }
+                return self._with_auction_watchlist(result, data_date, user_id)
+
+        if use_ifind_snapshot:
+            rows = self._dynamic_auction_rows(data_date, previous_date, user_id)
+        else:
+            rows = []
+        if not rows and not live_dynamic:
+            try:
+                rows = self.client.query("stk_auction", {"trade_date": data_date})
+            except TushareError:
+                rows = self.database.auction_factors_for_date(data_date)
+        if not rows:
+            return {
+                "meta": {
+                    **session,
+                    "requested_date": _display_date(requested_date),
+                    "trade_date": _display_date(data_date),
+                    "carried_forward": carried_forward,
+                    "available": False,
+                    "cached": False,
+                    "notice": "该交易日暂无可用竞价快照",
+                    "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                },
+                "summary": {
+                    "stock_count": 0, "up_count": 0, "down_count": 0,
+                    "limit_open_count": 0, "strong_open_count": 0,
+                    "median_change": 0, "amount_billion": 0,
+                    "candidate_count": 0, "focus_count": 0, "one_price_count": 0,
+                },
+                "expectations": {"超预期": 0, "符合预期": 0, "低于预期": 0},
+                "candidate_meta": {"baseline_date": _display_date(previous_date)},
+                "themes": {"carry": [], "new_themes": []},
+                "amount_history": self._auction_amount_history(data_date),
+                "news_feedback": {"available": False, "message": "隔夜消息反馈暂不可用"},
+                "focus_rows": [], "one_price_rows": [], "rows": [],
+                "watchlist_rows": [], "watchlist_missing_count": 0,
+            }
+
+        master = self._stock_master()
+        try:
+            limit_rows = self.client.query(
+                "stk_limit",
+                {"trade_date": data_date},
+                "trade_date,ts_code,up_limit,down_limit",
+            )
+        except TushareError:
+            limit_rows = []
+        limit_map = {str(item.get("ts_code") or ""): item for item in limit_rows}
+        normalized = []
+        for row in rows:
+            ts_code = str(row.get("ts_code") or "")
+            stock = master.get(ts_code)
+            price = _number(row.get("price"))
+            pre_close = _number(row.get("pre_close"))
+            list_date = str((stock or {}).get("list_date") or "")
+            if (
+                not stock
+                or price <= 0
+                or pre_close <= 0
+                or (list_date and list_date >= data_date)
+            ):
+                continue
+            change = (price / pre_close - 1) * 100
+            amount_million = _number(row.get("amount")) / 1_000_000
+            volume_ratio = _number(row.get("volume_ratio"))
+            turnover_rate = _number(row.get("turnover_rate"))
+            up_limit = _number((limit_map.get(ts_code) or {}).get("up_limit"))
+            is_one_price = bool(
+                up_limit > 0 and abs(price - up_limit) <= max(0.001, up_limit * 0.00005)
+            )
+            normalized.append(
+                {
+                    "code": str(stock.get("code") or ts_code.split(".")[0]),
+                    "ts_code": ts_code,
+                    "name": str(stock.get("name") or "--"),
+                    "sector": str(stock.get("industry") or "其他"),
+                    "price": round(price, 2),
+                    "pre_close": round(pre_close, 2),
+                    "change": round(change, 2),
+                    "volume_ten_thousand": round(_number(row.get("vol")) / 10_000, 2),
+                    "amount_million": round(amount_million, 2),
+                    "turnover_rate": round(turnover_rate, 4),
+                    "volume_ratio": round(volume_ratio, 2),
+                    "up_limit": round(up_limit, 2) if up_limit else None,
+                    "is_one_price": is_one_price,
+                    "signal": (
+                        "竞价涨停" if change >= 9.5 else
+                        "强势高开" if change >= 3 else
+                        "高开" if change > 0.2 else
+                        "深度低开" if change <= -3 else
+                        "低开" if change < -0.2 else "平开"
+                    ),
+                }
+            )
+        normalized.sort(key=lambda item: (item["amount_million"], item["volume_ratio"]), reverse=True)
+        self.database.upsert_auction_factors(rows)
+        changes = [item["change"] for item in normalized]
+        total = len(normalized)
+        _, baseline_date = self._trade_context(data_date)
+        candidates, candidate_meta, focus_rows = self._auction_candidates(normalized, baseline_date)
+        candidate_map = {str(item.get("code") or ""): item for item in candidates}
+        one_price_rows = []
+        for row in normalized:
+            if not row.get("is_one_price"):
+                continue
+            enriched = candidate_map.get(str(row.get("code") or ""), {})
+            one_price_rows.append(
+                {
+                    **row,
+                    **enriched,
+                    "attention_score": None,
+                    "expectation": "",
+                    "expected_change": None,
+                    "expectation_reason": "竞价价格封于当日涨停价，已从普通异动评分中隔离",
+                }
+            )
+        one_price_codes = {str(item.get("code") or "") for item in one_price_rows}
+        candidates = [item for item in candidates if str(item.get("code") or "") not in one_price_codes]
+        focus_rows = [item for item in focus_rows if str(item.get("code") or "") not in one_price_codes]
+        one_price_rows.sort(
+            key=lambda item: (
+                bool(item.get("is_market_core")),
+                _number(item.get("prior_streak")),
+                _number(item.get("amount_million")),
+            ),
+            reverse=True,
+        )
+        expectations = {
+            label: sum(item.get("expectation") == label for item in candidates)
+            for label in ("超预期", "符合预期", "低于预期")
+        }
+        prior_snapshot = self.database.get_snapshot(baseline_date) or {}
+        themes = self._auction_theme_evidence(prior_snapshot, candidates + one_price_rows)
+        self._ensure_auction_amount_history(data_date)
+        amount_history = self._auction_amount_history(data_date)
+        prior_amounts = [item["amount_billion"] for item in amount_history[:-1]]
+        current_amount = round(sum(item["amount_million"] for item in normalized) / 100, 2)
+        previous_amount = prior_amounts[-1] if prior_amounts else 0
+        five_day_amounts = prior_amounts[-5:]
+        five_day_average = sum(five_day_amounts) / len(five_day_amounts) if five_day_amounts else 0
+        result = {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(data_date),
+                "carried_forward": carried_forward,
+                "available": bool(normalized),
+                **session,
+                "cached": False,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+            },
+            "summary": {
+                "stock_count": total,
+                "up_count": sum(value > 0.2 for value in changes),
+                "down_count": sum(value < -0.2 for value in changes),
+                "limit_open_count": len(one_price_rows),
+                "strong_open_count": sum(value >= 3 for value in changes),
+                "median_change": round(median(changes), 2) if changes else 0,
+                "amount_billion": current_amount,
+                "amount_change_previous": round((current_amount / previous_amount - 1) * 100, 1) if previous_amount else None,
+                "amount_change_5d": round((current_amount / five_day_average - 1) * 100, 1) if five_day_average else None,
+                "candidate_count": len(candidates),
+                "focus_count": len(focus_rows),
+                "one_price_count": len(one_price_rows),
+            },
+            "expectations": expectations,
+            "candidate_meta": candidate_meta,
+            "themes": themes,
+            "amount_history": amount_history,
+            "news_feedback": {
+                "available": False,
+                "message": "隔夜消息反馈暂不可用",
+                "detail": "待稳定的新闻与公告数据接入后开放",
+            },
+            "focus_rows": focus_rows,
+            "one_price_rows": one_price_rows,
+            "rows": candidates,
+        }
+        if not live_dynamic:
+            self.database.save_data_snapshot("auction_center_v6", cache_key, "market", result)
+        return self._with_auction_watchlist(result, data_date, user_id)

app/backend/features/market/insights_auction_data.py

@@ -0,0 +1,318 @@
+from __future__ import annotations
+
+import copy
+from datetime import datetime, time as dt_time, timedelta
+from typing import Any
+
+from backend.data.numbers import non_nan_number as _number
+from backend.data.providers.ifind_client import IfindError
+from backend.data.providers.tushare_client import TushareError
+from backend.features.market.insights_context import CHINA_TIMEZONE, _display_date
+
+
+class MarketAuctionDataMixin:
+    def _auction_session(self, requested_date: str, trade_date: str) -> dict[str, Any]:
+        now = self._now_provider()
+        if now.tzinfo is None:
+            now = now.replace(tzinfo=CHINA_TIMEZONE)
+        else:
+            now = now.astimezone(CHINA_TIMEZONE)
+        requested = str(requested_date or "").replace("-", "")
+        today = now.strftime("%Y%m%d")
+        if requested != today or trade_date != today:
+            return {
+                "phase": "archive",
+                "actionable": False,
+                "next_transition_at": "",
+            }
+
+        local_time = now.time().replace(tzinfo=None)
+        transitions = (
+            (dt_time(9, 15), "pending", dt_time(9, 15)),
+            (dt_time(9, 25), "observing", dt_time(9, 25)),
+            (dt_time(9, 30), "selection", dt_time(9, 30)),
+        )
+        for boundary, phase, next_boundary in transitions:
+            if local_time < boundary:
+                transition = now.replace(
+                    hour=next_boundary.hour,
+                    minute=next_boundary.minute,
+                    second=0,
+                    microsecond=0,
+                )
+                return {
+                    "phase": phase,
+                    "actionable": phase == "selection",
+                    "next_transition_at": transition.isoformat(timespec="seconds"),
+                }
+        return {
+            "phase": "finalized",
+            "actionable": False,
+            "next_transition_at": "",
+        }
+
+    def _auction_amount_history(self, trade_date: str) -> list[dict[str, Any]]:
+        dates = self.database.auction_factor_dates(trade_date, 10)
+        stock_list_dates = {
+            str(item.get("ts_code") or ""): str(item.get("list_date") or "")
+            for item in self.database.list_stock_master()
+            if item.get("ts_code")
+        }
+        history = []
+        for current_date in dates:
+            rows = [
+                row for row in self.database.auction_factors_for_date(current_date)
+                if (
+                    str(row.get("ts_code") or "") in stock_list_dates
+                    and (
+                        not stock_list_dates[str(row.get("ts_code") or "")]
+                        or stock_list_dates[str(row.get("ts_code") or "")] < current_date
+                    )
+                )
+            ]
+            history.append(
+                {
+                    "trade_date": _display_date(current_date),
+                    "amount_billion": round(sum(_number(row.get("amount")) for row in rows) / 100_000_000, 2),
+                    "stock_count": len(rows),
+                }
+            )
+        return history
+
+    def _ensure_auction_amount_history(self, trade_date: str, target_days: int = 10) -> None:
+        existing = set(self.database.auction_factor_dates(trade_date, target_days + 5))
+        if len(existing) >= target_days:
+            return
+        end = datetime.strptime(trade_date, "%Y%m%d")
+        start = (end - timedelta(days=35)).strftime("%Y%m%d")
+        try:
+            calendar = self.client.query(
+                "trade_cal",
+                {
+                    "exchange": "SSE",
+                    "start_date": start,
+                    "end_date": trade_date,
+                    "is_open": 1,
+                },
+                "cal_date,is_open",
+            )
+        except TushareError:
+            return
+        dates = sorted(
+            str(item.get("cal_date") or "")
+            for item in calendar
+            if int(_number(item.get("is_open"))) == 1 and item.get("cal_date")
+        )[-target_days:]
+        for current_date in dates:
+            if current_date in existing:
+                continue
+            try:
+                rows = self.client.query(
+                    "stk_auction",
+                    {"trade_date": current_date},
+                    "ts_code,trade_date,vol,price,amount,pre_close,turnover_rate,volume_ratio,float_share",
+                )
+            except TushareError:
+                break
+            if rows:
+                self.database.upsert_auction_factors(rows)
+                existing.add(current_date)
+
+    def _with_auction_watchlist(
+        self,
+        result: dict[str, Any],
+        trade_date: str,
+        user_id: int,
+    ) -> dict[str, Any]:
+        personalized = copy.deepcopy(result)
+        if not user_id:
+            personalized["watchlist_rows"] = []
+            personalized["watchlist_missing_count"] = 0
+            return personalized
+        watched = self.database.list_watchlist(user_id)
+        if not watched:
+            personalized["watchlist_rows"] = []
+            personalized["watchlist_missing_count"] = 0
+            return personalized
+
+        public_rows = {
+            str(item.get("code") or ""): item
+            for item in (
+                list(personalized.get("rows") or [])
+                + list(personalized.get("one_price_rows") or [])
+            )
+        }
+        factors = {
+            str(item.get("ts_code") or "").split(".")[0]: item
+            for item in self.database.auction_factors_for_date(trade_date)
+        }
+        master = {
+            str(item.get("ts_code") or "").split(".")[0]: item
+            for item in self.database.list_stock_master()
+        }
+        rows = []
+        missing = 0
+        for item in watched:
+            code = str(item.get("code") or "")
+            if code in public_rows:
+                rows.append({**public_rows[code], "is_watchlist": True})
+                continue
+            factor = factors.get(code)
+            if not factor:
+                missing += 1
+                rows.append(
+                    {
+                        "code": code,
+                        "name": str(item.get("name") or "--"),
+                        "sector": str(item.get("sector") or "其他"),
+                        "available": False,
+                        "is_watchlist": True,
+                    }
+                )
+                continue
+            stock = master.get(code, {})
+            price = _number(factor.get("price"))
+            pre_close = _number(factor.get("pre_close"))
+            change = (price / pre_close - 1) * 100 if price > 0 and pre_close > 0 else 0
+            row = {
+                "code": code,
+                "ts_code": str(factor.get("ts_code") or ""),
+                "name": str(item.get("name") or stock.get("name") or "--"),
+                "sector": str(item.get("sector") or stock.get("industry") or "其他"),
+                "price": round(price, 2),
+                "pre_close": round(pre_close, 2),
+                "change": round(change, 2),
+                "amount_million": round(_number(factor.get("amount")) / 1_000_000, 2),
+                "turnover_rate": round(_number(factor.get("turnover_rate")), 4),
+                "volume_ratio": round(_number(factor.get("volume_ratio")), 2),
+                "candidate_sources": ["我的自选"],
+                "source_label": "我的自选",
+                "prior_streak": 0,
+                "concepts": [],
+                "expected_change": 0.0,
+                "core_tags": [],
+                "is_market_core": False,
+                "is_watchlist": True,
+                "available": True,
+            }
+            actual_strength = change + self._auction_confirmation(row)
+            row["actual_strength"] = round(actual_strength, 2)
+            row["expectation"] = self._expectation_label(actual_strength, 0.0)
+            row["attention_score"] = self._attention_score(row, 0.0, [], ["我的自选"], 0, False)
+            direction = "高于" if change > 0 else "低于" if change < 0 else "贴合"
+            row["expectation_reason"] = f"自选观察；竞价涨幅{direction}个人观察基准{abs(change):.1f}个百分点，量比{row['volume_ratio']:.2f}"
+            rows.append(row)
+        rows.sort(
+            key=lambda row: (bool(row.get("available", True)), _number(row.get("attention_score"))),
+            reverse=True,
+        )
+        personalized["watchlist_rows"] = rows
+        personalized["watchlist_missing_count"] = missing
+        return personalized
+
+    def _dynamic_auction_rows(
+        self,
+        trade_date: str,
+        baseline_date: str,
+        user_id: int,
+    ) -> list[dict[str, Any]]:
+        if not self.ifind or not self.ifind.configured:
+            return []
+        master = self._stock_master()
+        placeholders = [
+            {
+                "code": str(item.get("code") or ts_code.split(".")[0]),
+                "ts_code": ts_code,
+                "name": str(item.get("name") or "--"),
+                "sector": str(item.get("industry") or "其他"),
+            }
+            for ts_code, item in master.items()
+        ]
+        candidates, _, _ = self._auction_candidates(placeholders, baseline_date)
+        selected_codes = {
+            str(item.get("ts_code") or "")
+            for item in candidates
+            if item.get("ts_code")
+        }
+        if user_id:
+            watched = {str(item.get("code") or "") for item in self.database.list_watchlist(user_id)}
+            selected_codes.update(
+                ts_code for ts_code in master if ts_code.split(".")[0] in watched
+            )
+        selected_codes.discard("")
+        if not selected_codes:
+            return []
+
+        display_date = _display_date(trade_date)
+        now = self._now_provider()
+        if now.tzinfo is None:
+            now = now.replace(tzinfo=CHINA_TIMEZONE)
+        else:
+            now = now.astimezone(CHINA_TIMEZONE)
+        end_time = min(now.time().replace(tzinfo=None), dt_time(9, 25))
+        end_stamp = f"{display_date} {end_time.strftime('%H:%M:%S')}"
+        start_stamp = f"{display_date} 09:15:00"
+        snapshot_rows: list[dict[str, Any]] = []
+        ordered_codes = sorted(selected_codes)
+        for index in range(0, len(ordered_codes), 80):
+            try:
+                snapshot_rows.extend(
+                    self.ifind.snapshots(
+                        ordered_codes[index:index + 80],
+                        [
+                            "latest", "volume", "amount", "preClose",
+                            "bid1", "bidSize1", "ask1", "askSize1",
+                        ],
+                        start_stamp,
+                        end_stamp,
+                        cache_ttl=8,
+                    )
+                )
+            except IfindError:
+                continue
+
+        latest: dict[str, dict[str, Any]] = {}
+        for row in snapshot_rows:
+            ts_code = str(row.get("thscode") or "")
+            previous = latest.get(ts_code) or {}
+            if (
+                ts_code
+                and _number(row.get("latest")) > 0
+                and str(row.get("time") or "") >= str(previous.get("time") or "")
+            ):
+                latest[ts_code] = row
+        prior_factors = {
+            str(item.get("ts_code") or ""): item
+            for item in self.database.auction_factors_for_date(baseline_date)
+        }
+        normalized = []
+        for ts_code, row in latest.items():
+            price = _number(row.get("latest"))
+            pre_close = _number(row.get("preClose"))
+            volume = _number(row.get("volume"))
+            bid_size = _number(row.get("bidSize1"))
+            ask_size = _number(row.get("askSize1"))
+            if volume <= 0 and bid_size > 0 and ask_size > 0:
+                volume = min(bid_size, ask_size)
+            amount = _number(row.get("amount"))
+            if amount <= 0 and price > 0 and volume > 0:
+                amount = price * volume
+            prior_volume = _number((prior_factors.get(ts_code) or {}).get("vol"))
+            normalized.append(
+                {
+                    "ts_code": ts_code,
+                    "trade_date": trade_date,
+                    "vol": volume,
+                    "price": price,
+                    "amount": amount,
+                    "pre_close": pre_close,
+                    "turnover_rate": 0,
+                    "volume_ratio": volume / prior_volume if prior_volume > 0 else 0,
+                    "float_share": 0,
+                    "bid_size1": bid_size,
+                    "ask_size1": ask_size,
+                    "snapshot_time": str(row.get("time") or ""),
+                    "dynamic": True,
+                }
+            )
+        return normalized

app/backend/features/market/insights_auction_scoring.py

@@ -0,0 +1,355 @@
+from __future__ import annotations
+
+from statistics import median
+from typing import Any
+
+from backend.data.numbers import non_nan_number as _number
+from backend.features.market.insights_context import _display_date
+
+
+class MarketAuctionScoringMixin:
+    @staticmethod
+    def _expectation_label(actual_strength: float, expected_change: float) -> str:
+        difference = actual_strength - expected_change
+        if difference >= 1.5:
+            return "超预期"
+        if difference <= -1.5:
+            return "低于预期"
+        return "符合预期"
+
+    @staticmethod
+    def _auction_confirmation(row: dict[str, Any]) -> float:
+        volume_ratio = _number(row.get("volume_ratio"))
+        turnover_rate = _number(row.get("turnover_rate"))
+        amount_million = _number(row.get("amount_million"))
+        return (
+            (0.6 if volume_ratio >= 2 else 0.3 if volume_ratio >= 1.2 else -0.5 if volume_ratio < 0.6 else 0)
+            + (0.25 if turnover_rate >= 0.15 else -0.25 if turnover_rate < 0.03 else 0)
+            + (0.3 if amount_million >= 20 else 0.15 if amount_million >= 5 else -0.3 if amount_million < 1 else 0)
+        )
+
+    @staticmethod
+    def _attention_score(
+        row: dict[str, Any],
+        expected_change: float,
+        core_tags: list[str],
+        sources: list[str],
+        prior_streak: int,
+        strong_sector: bool,
+    ) -> float:
+        if core_tags:
+            identity_score = 35.0
+        elif prior_streak >= 2:
+            identity_score = 27.0
+        elif any(source in {"昨日涨停", "昨日炸板"} for source in sources):
+            identity_score = 21.0
+        else:
+            identity_score = 14.0
+        deviation_score = min(30.0, abs(_number(row.get("change")) - expected_change) * 5)
+        volume_score = min(10.0, max(0.0, _number(row.get("volume_ratio"))) / 2 * 10)
+        amount_score = min(6.0, max(0.0, _number(row.get("amount_million"))) / 10 * 6)
+        turnover_score = min(4.0, max(0.0, _number(row.get("turnover_rate"))) / 0.2 * 4)
+        theme_score = 15.0 if strong_sector else 7.0 if row.get("concepts") else 0.0
+        return round(min(100.0, identity_score + deviation_score + volume_score + amount_score + turnover_score + theme_score), 1)
+
+    def _auction_candidates(
+        self,
+        rows: list[dict[str, Any]],
+        baseline_date: str,
+    ) -> tuple[list[dict[str, Any]], dict[str, Any], list[dict[str, Any]]]:
+        """Build a narrow, explainable universe from prior limits, breaks and top-20 hot lists."""
+        snapshot = self.database.get_snapshot(baseline_date) or {}
+        prior_limits = list(snapshot.get("limits") or [])
+        prior_broken = list(snapshot.get("broken") or [])
+        prior_sectors = list(snapshot.get("sectors") or [])
+        strong_sector_names = {
+            str(item.get("name") or "") for item in prior_sectors[:5] if item.get("name")
+        }
+        ths_rows, dc_rows, errors = self._hot_rows(baseline_date)
+        candidates: dict[str, dict[str, Any]] = {}
+        core_tags: dict[str, set[str]] = {}
+
+        def ensure_candidate(item: dict[str, Any]) -> dict[str, Any] | None:
+            code = str(item.get("code") or str(item.get("ts_code") or "").split(".")[0])
+            if not code:
+                return None
+            return candidates.setdefault(
+                code,
+                {
+                    "sources": [],
+                    "streak": 0,
+                    "sector": str(item.get("sector") or "其他"),
+                    "name": str(item.get("name") or item.get("ts_name") or "--"),
+                    "concepts": [],
+                    "ths_rank": None,
+                    "dc_rank": None,
+                },
+            )
+
+        for item in prior_limits:
+            candidate = ensure_candidate(item)
+            if candidate is None:
+                continue
+            candidate["sources"].append("昨日涨停")
+            candidate["streak"] = max(1, int(_number(item.get("streak"), 1)))
+
+        for item in prior_broken:
+            candidate = ensure_candidate(item)
+            if candidate is not None and "昨日炸板" not in candidate["sources"]:
+                candidate["sources"].append("昨日炸板")
+
+        limit_streaks = [max(1, int(_number(item.get("streak"), 1))) for item in prior_limits]
+        highest_streak = max(limit_streaks, default=0)
+        for item in prior_limits:
+            code = str(item.get("code") or "")
+            streak = max(1, int(_number(item.get("streak"), 1)))
+            if streak >= 3:
+                core_tags.setdefault(code, set()).add("三板以上")
+            if highest_streak and streak == highest_streak:
+                core_tags.setdefault(code, set()).add("市场最高板")
+
+        for sector in prior_sectors[:5]:
+            name = str(sector.get("name") or "")
+            members = [item for item in prior_limits if str(item.get("sector") or "其他") == name]
+            if not members:
+                continue
+            leader = max(
+                members,
+                key=lambda item: (
+                    int(_number(item.get("streak"), 1)),
+                    _number(item.get("amount_billion")),
+                    -_number(item.get("open_times")),
+                ),
+            )
+            core_tags.setdefault(str(leader.get("code") or ""), set()).add("题材核心")
+
+        leadership = sorted(
+            prior_limits,
+            key=lambda item: (
+                int(_number(item.get("streak"), 1)),
+                str(item.get("sector") or "") in strong_sector_names,
+                _number(item.get("amount_billion")),
+            ),
+            reverse=True,
+        )
+        if leadership:
+            core_tags.setdefault(str(leadership[0].get("code") or ""), set()).add("市场领涨")
+
+        hot_records: dict[str, dict[str, Any]] = {}
+
+        for source, hot_rows, data_type in (
+            ("同花顺热榜", ths_rows, "热股"),
+            ("东方财富热榜", dc_rows, "A股市场"),
+        ):
+            for item in hot_rows:
+                if str(item.get("data_type") or "") != data_type:
+                    continue
+                ts_code = str(item.get("ts_code") or "")
+                code = ts_code.split(".")[0]
+                rank = max(1, int(_number(item.get("rank"), 9999)))
+                if not code or rank > 20:
+                    continue
+                hot = hot_records.setdefault(
+                    code,
+                    {
+                        "name": str(item.get("ts_name") or "--"),
+                        "concepts": [],
+                        "ths_rank": None,
+                        "dc_rank": None,
+                    },
+                )
+                hot["ths_rank" if source == "同花顺热榜" else "dc_rank"] = rank
+                if source == "同花顺热榜":
+                    hot["concepts"] = self._parse_concepts(item.get("concept"))
+
+        ranked_hot = sorted(
+            hot_records.items(),
+            key=lambda pair: (
+                ((21 - (pair[1].get("ths_rank") or 21)) / 20)
+                + ((21 - (pair[1].get("dc_rank") or 21)) / 20)
+                + (0.35 if pair[1].get("ths_rank") and pair[1].get("dc_rank") else 0)
+            ),
+            reverse=True,
+        )
+        for code, _ in ranked_hot[:5]:
+            core_tags.setdefault(code, set()).add("人气前5")
+
+        for code, hot in hot_records.items():
+            ranks = [rank for rank in (hot.get("ths_rank"), hot.get("dc_rank")) if isinstance(rank, int)]
+            dual = len(ranks) == 2
+            if not ranks or (min(ranks) > 10 and not dual and code not in candidates and code not in core_tags):
+                continue
+            candidate = candidates.setdefault(
+                code,
+                {
+                    "sources": [],
+                    "streak": 0,
+                    "sector": "其他",
+                    "name": hot["name"],
+                    "concepts": [],
+                    "ths_rank": None,
+                    "dc_rank": None,
+                },
+            )
+            candidate["ths_rank"] = hot.get("ths_rank")
+            candidate["dc_rank"] = hot.get("dc_rank")
+            candidate["concepts"] = hot.get("concepts") or []
+            if hot.get("ths_rank") and "同花顺热榜" not in candidate["sources"]:
+                candidate["sources"].append("同花顺热榜")
+            if hot.get("dc_rank") and "东方财富热榜" not in candidate["sources"]:
+                candidate["sources"].append("东方财富热榜")
+
+        normalized = []
+        for row in rows:
+            candidate = candidates.get(str(row.get("code") or ""))
+            if not candidate:
+                continue
+            streak = int(candidate["streak"])
+            expected_change = {1: 1.5, 2: 3.0, 3: 4.0}.get(streak, 5.0 if streak else 0.5)
+            ranks = [
+                rank for rank in (candidate.get("ths_rank"), candidate.get("dc_rank"))
+                if isinstance(rank, int)
+            ]
+            if len(ranks) == 2:
+                expected_change += 0.8
+            elif ranks:
+                best_rank = min(ranks)
+                expected_change += 0.7 if best_rank <= 10 else 0.4 if best_rank <= 30 else 0.2
+            expected_change = min(expected_change, 6.5)
+
+            volume_ratio = _number(row.get("volume_ratio"))
+            turnover_rate = _number(row.get("turnover_rate"))
+            amount_million = _number(row.get("amount_million"))
+            confirmation = self._auction_confirmation(row)
+            actual_strength = _number(row.get("change")) + confirmation
+            label = self._expectation_label(actual_strength, expected_change)
+            is_broken = "昨日炸板" in candidate["sources"] and "昨日涨停" not in candidate["sources"]
+            identity = f"昨日{streak}板" if streak > 1 else "昨日首板" if streak == 1 else "昨日炸板" if is_broken else "人气榜标的"
+            popularity = "，双榜共识" if len(ranks) == 2 else "，热榜靠前" if ranks and min(ranks) <= 10 else ""
+            difference = _number(row.get("change")) - expected_change
+            direction = "高于" if difference > 0 else "低于" if difference < 0 else "贴合"
+            reason = (
+                f"{identity}{popularity}；竞价涨幅{direction}预期中枢"
+                f"{abs(difference):.1f}个百分点，量比{volume_ratio:.2f}"
+            )
+            tags = sorted(core_tags.get(str(row.get("code") or ""), set()))
+            scored_row = {
+                **row,
+                "concepts": candidate["concepts"],
+            }
+            attention_score = self._attention_score(
+                scored_row,
+                expected_change,
+                tags,
+                candidate["sources"],
+                streak,
+                str(candidate.get("sector") or row.get("sector") or "") in strong_sector_names,
+            )
+            normalized.append(
+                {
+                    **scored_row,
+                    "sector": candidate["sector"] if candidate["sector"] != "其他" else row.get("sector", "其他"),
+                    "candidate_sources": candidate["sources"],
+                    "source_label": " · ".join(candidate["sources"]),
+                    "prior_streak": streak,
+                    "concepts": candidate["concepts"],
+                    "expected_change": round(expected_change, 2),
+                    "actual_strength": round(actual_strength, 2),
+                    "expectation": label,
+                    "attention_score": attention_score,
+                    "core_tags": tags,
+                    "is_market_core": bool(tags),
+                    "expectation_reason": reason,
+                }
+            )
+        normalized.sort(key=lambda item: (_number(item.get("attention_score")), _number(item.get("amount_million"))), reverse=True)
+        matched_top = {
+            str(item.get("code") or "")
+            for item in sorted(
+                (item for item in normalized if item.get("expectation") == "符合预期"),
+                key=lambda item: _number(item.get("attention_score")),
+                reverse=True,
+            )[:20]
+        }
+        focus_candidates = [
+            item for item in normalized
+            if item.get("is_market_core")
+            or (_number(item.get("attention_score")) >= 55 and item.get("expectation") != "符合预期")
+            or str(item.get("code") or "") in matched_top
+        ]
+        mandatory = [item for item in focus_candidates if item.get("is_market_core")]
+        mandatory_codes = {str(item.get("code") or "") for item in mandatory}
+        optional = [item for item in focus_candidates if str(item.get("code") or "") not in mandatory_codes]
+        focus_rows = sorted(mandatory, key=lambda item: _number(item.get("attention_score")), reverse=True)
+        focus_rows.extend(optional[:max(0, 30 - len(focus_rows))])
+        focus_rows.sort(key=lambda item: _number(item.get("attention_score")), reverse=True)
+        return normalized, {
+            "baseline_date": _display_date(baseline_date),
+            "prior_limit_count": len(prior_limits),
+            "prior_broken_count": len(prior_broken),
+            "hot_candidate_count": sum(
+                any(source in {"同花顺热榜", "东方财富热榜"} for source in item["sources"])
+                for item in candidates.values()
+            ),
+            "core_count": sum(bool(item.get("is_market_core")) for item in normalized),
+            "notice": "；".join(errors),
+        }, focus_rows
+
+    @staticmethod
+    def _auction_theme_evidence(
+        prior_snapshot: dict[str, Any],
+        candidate_rows: list[dict[str, Any]],
+    ) -> dict[str, list[dict[str, Any]]]:
+        prior_sectors = list(prior_snapshot.get("sectors") or [])
+        carry = []
+        for sector in prior_sectors[:10]:
+            name = str(sector.get("name") or "其他")
+            matched = [row for row in candidate_rows if str(row.get("sector") or "其他") == name]
+            changes = [_number(row.get("change")) for row in matched]
+            middle = median(changes) if changes else -10.0
+            positive_rate = sum(value > 0.2 for value in changes) / len(changes) * 100 if changes else 0.0
+            if middle >= 2 and positive_rate >= 60:
+                status = "强承接"
+            elif middle >= 0 and positive_rate >= 50:
+                status = "有承接"
+            elif middle > -2:
+                status = "分歧"
+            else:
+                status = "承接弱"
+            carry.append(
+                {
+                    "name": name,
+                    "status": status,
+                    "prior_limit_count": int(_number(sector.get("count"))),
+                    "leader": str(sector.get("leader") or "--"),
+                    "matched_count": len(matched),
+                    "median_change": round(middle, 2) if matched else None,
+                    "positive_rate": round(positive_rate, 1),
+                    "amount_million": round(sum(_number(row.get("amount_million")) for row in matched), 2),
+                }
+            )
+
+        concept_groups: dict[str, list[dict[str, Any]]] = {}
+        prior_names = {str(item.get("name") or "") for item in prior_sectors}
+        for row in candidate_rows:
+            for concept in row.get("concepts") or []:
+                if concept and concept not in prior_names:
+                    concept_groups.setdefault(str(concept), []).append(row)
+        new_themes = []
+        for name, members in concept_groups.items():
+            unique = {str(item.get("code") or ""): item for item in members}
+            values = list(unique.values())
+            changes = [_number(item.get("change")) for item in values]
+            if len(values) < 2 or median(changes) < 2 or sum(value > 0.2 for value in changes) / len(values) < 0.67:
+                continue
+            new_themes.append(
+                {
+                    "name": name,
+                    "stock_count": len(values),
+                    "median_change": round(median(changes), 2),
+                    "amount_million": round(sum(_number(item.get("amount_million")) for item in values), 2),
+                    "leaders": [str(item.get("name") or "--") for item in sorted(values, key=lambda value: _number(value.get("change")), reverse=True)[:3]],
+                }
+            )
+        new_themes.sort(key=lambda item: (item["stock_count"], item["median_change"], item["amount_million"]), reverse=True)
+        return {"carry": carry, "new_themes": new_themes[:8]}

app/backend/features/market/insights_context.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime, timedelta, timezone
+from typing import TYPE_CHECKING, Any, Callable
+
+from backend.data.providers.ifind_client import IfindHttpClient
+from backend.data.providers.tushare_client import TushareClient, TushareError
+
+if TYPE_CHECKING:
+    from database import ReviewDatabase
+
+
+CHINA_TIMEZONE = timezone(timedelta(hours=8))
+
+def _display_date(value: str) -> str:
+    text = str(value or "").replace("-", "")
+    if len(text) != 8:
+        return str(value or "")
+    return f"{text[:4]}-{text[4:6]}-{text[6:]}"
+
+
+class MarketInsightsContextMixin:
+    def __init__(
+        self,
+        database: ReviewDatabase,
+        client: TushareClient,
+        now_provider: Callable[[], datetime] | None = None,
+        ifind: IfindHttpClient | None = None,
+    ) -> None:
+        self.database = database
+        self.client = client
+        self._now_provider = now_provider or (lambda: datetime.now(CHINA_TIMEZONE))
+        self.ifind = ifind
+
+    def _trade_context(self, requested_date: str) -> tuple[str, str]:
+        """Resolve trading dates without making cached feature pages depend on Tushare uptime."""
+        requested = str(requested_date or "").replace("-", "")
+        try:
+            return self.client.resolve_trade_context(requested)
+        except TushareError:
+            latest = self.database.get_latest_real_snapshot(requested) or {}
+            trade_date = str(
+                (latest.get("meta") or {}).get("trade_date")
+                or latest.get("_snapshot_date")
+                or requested
+            ).replace("-", "")
+            previous = self.database.get_latest_real_snapshot(trade_date, strictly_before=True) or {}
+            previous_date = str(
+                (previous.get("meta") or {}).get("trade_date")
+                or previous.get("_snapshot_date")
+                or ""
+            ).replace("-", "")
+            return trade_date, previous_date
+
+    def _latest_feature_snapshot(self, kind: str, trade_date: str) -> dict[str, Any] | None:
+        return self.database.get_latest_data_snapshot(kind, "", trade_date)
+
+    def _stock_master(self) -> dict[str, dict[str, Any]]:
+        rows = self.database.list_stock_master()
+        if not rows:
+            rows = self.client.query(
+                "stock_basic",
+                {"list_status": "L"},
+                "ts_code,name,industry,market,list_date",
+            )
+            self.database.upsert_stock_master(rows)
+            rows = self.database.list_stock_master()
+        return {str(row.get("ts_code") or ""): row for row in rows}
+
+    @staticmethod
+    def _parse_concepts(value: Any) -> list[str]:
+        if isinstance(value, list):
+            return [str(item) for item in value if str(item).strip()]
+        text = str(value or "").strip()
+        if not text:
+            return []
+        try:
+            parsed = json.loads(text)
+            if isinstance(parsed, list):
+                return [str(item) for item in parsed if str(item).strip()]
+        except json.JSONDecodeError:
+            pass
+        return [part.strip() for part in text.split(",") if part.strip()]

app/backend/features/market/insights_popularity.py

@@ -0,0 +1,156 @@
+from __future__ import annotations
+
+import copy
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.data.numbers import non_nan_number as _number
+from backend.data.providers.tushare_client import TushareError
+from backend.features.market.insights_context import _display_date
+
+
+class MarketPopularityInsightsMixin:
+    def popularity(self, requested_date: str, force: bool = False) -> dict[str, Any]:
+        trade_date, previous_date = self._trade_context(requested_date)
+        if not force:
+            cached = self.database.get_data_snapshot("popularity_v1", trade_date)
+            if cached:
+                result = copy.deepcopy(cached)
+                result["meta"] = {**result.get("meta", {}), "cached": True}
+                return result
+
+        ths_rows, dc_rows, errors = self._hot_rows(trade_date)
+        actual_date = trade_date
+        carried_forward = False
+        if not ths_rows and not dc_rows and previous_date:
+            ths_rows, dc_rows, errors = self._hot_rows(previous_date)
+            actual_date = previous_date
+            carried_forward = bool(ths_rows or dc_rows)
+        if not ths_rows and not dc_rows:
+            fallback = self._latest_feature_snapshot("popularity_v1", trade_date)
+            if fallback:
+                result = copy.deepcopy(fallback)
+                result["meta"] = {
+                    **result.get("meta", {}),
+                    "requested_date": _display_date(requested_date),
+                    "carried_forward": True,
+                    "cached": True,
+                    "notice": "当前榜单暂不可用，展示最近有效快照",
+                }
+                return result
+            return {
+                "meta": {
+                    "requested_date": _display_date(requested_date),
+                    "trade_date": _display_date(trade_date),
+                    "previous_trade_date": _display_date(previous_date),
+                    "carried_forward": False,
+                    "cached": False,
+                    "notice": "该交易日暂无可用人气榜",
+                    "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                },
+                "summary": {"ths_count": 0, "dc_count": 0, "dual_count": 0},
+                "combined": [], "ths": [], "dc": [],
+            }
+
+        prior_request = (datetime.strptime(actual_date, "%Y%m%d") - timedelta(days=1)).strftime("%Y%m%d")
+        prior_date, _ = self._trade_context(prior_request)
+        previous_ths, previous_dc, _ = self._hot_rows(prior_date)
+        ths = self._normalize_hot(ths_rows, "热股", previous_ths)
+        dc = self._normalize_hot(dc_rows, "A股市场", previous_dc)
+        ths_map = {item["ts_code"]: item for item in ths}
+        dc_map = {item["ts_code"]: item for item in dc}
+        combined = []
+        for ts_code in set(ths_map) | set(dc_map):
+            ths_item = ths_map.get(ts_code)
+            dc_item = dc_map.get(ts_code)
+            base = ths_item or dc_item or {}
+            ths_rank = int(ths_item["rank"]) if ths_item else None
+            dc_rank = int(dc_item["rank"]) if dc_item else None
+            score = (
+                (101 - (ths_rank or 101)) * 0.5
+                + (201 - (dc_rank or 201)) * 0.25
+            )
+            combined.append(
+                {
+                    **base,
+                    "ths_rank": ths_rank,
+                    "dc_rank": dc_rank,
+                    "score": round(score, 2),
+                    "dual_source": bool(ths_item and dc_item),
+                    "concepts": (ths_item or {}).get("concepts") or [],
+                }
+            )
+        combined.sort(key=lambda item: (item["dual_source"], item["score"]), reverse=True)
+        for index, item in enumerate(combined, 1):
+            item["rank"] = index
+        result = {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(actual_date),
+                "previous_trade_date": _display_date(prior_date),
+                "carried_forward": carried_forward,
+                "cached": False,
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "notice": "；".join(errors),
+            },
+            "summary": {
+                "ths_count": len(ths),
+                "dc_count": len(dc),
+                "dual_count": sum(item["dual_source"] for item in combined),
+            },
+            "combined": combined[:200],
+            "ths": ths,
+            "dc": dc,
+        }
+        self.database.save_data_snapshot("popularity_v1", trade_date, "market", result)
+        return result
+
+    def _hot_rows(self, trade_date: str) -> tuple[list[dict[str, Any]], list[dict[str, Any]], list[str]]:
+        errors = []
+        try:
+            ths = self.client.query("ths_hot", {"trade_date": trade_date})
+        except TushareError:
+            ths = []
+            errors.append("同花顺榜单暂不可用")
+        try:
+            dc = self.client.query("dc_hot", {"trade_date": trade_date})
+        except TushareError:
+            dc = []
+            errors.append("东方财富榜单暂不可用")
+        return ths, dc, errors
+
+    def _normalize_hot(
+        self,
+        rows: list[dict[str, Any]],
+        data_type: str,
+        previous_rows: list[dict[str, Any]],
+    ) -> list[dict[str, Any]]:
+        previous = {
+            str(row.get("ts_code") or ""): int(_number(row.get("rank")))
+            for row in previous_rows
+            if str(row.get("data_type") or "") == data_type
+        }
+        items = []
+        for row in rows:
+            if str(row.get("data_type") or "") != data_type:
+                continue
+            rank = int(_number(row.get("rank")))
+            ts_code = str(row.get("ts_code") or "")
+            prior_rank = previous.get(ts_code)
+            items.append(
+                {
+                    "rank": rank,
+                    "ts_code": ts_code,
+                    "code": ts_code.split(".")[0],
+                    "name": str(row.get("ts_name") or "--"),
+                    "change": round(_number(row.get("pct_change")), 2),
+                    "price": round(_number(row.get("current_price")), 2),
+                    "hot": round(_number(row.get("hot")), 1),
+                    "rank_change": (prior_rank - rank) if prior_rank else None,
+                    "concepts": self._parse_concepts(row.get("concept")),
+                    "reason": str(row.get("rank_reason") or ""),
+                    "rank_time": str(row.get("rank_time") or ""),
+                }
+            )
+        items.sort(key=lambda item: item["rank"])
+        return items

app/backend/features/market/insights_themes.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+import copy
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.data.numbers import non_nan_number as _number
+from backend.data.providers.tushare_client import TushareError
+from backend.features.market.insights_context import _display_date
+
+
+class MarketThemeInsightsMixin:
+    def _theme_directory(self) -> list[dict[str, Any]]:
+        cached = self.database.get_data_snapshot("theme_directory_v1", "ths") or {}
+        if cached.get("items"):
+            return list(cached["items"])
+        rows = self.client.query(
+            "ths_index", {}, "ts_code,name,count,exchange,list_date,type"
+        )
+        items = [
+            {
+                "code": str(row.get("ts_code") or ""),
+                "name": str(row.get("name") or ""),
+                "member_count": int(_number(row.get("count"))),
+                "list_date": str(row.get("list_date") or ""),
+            }
+            for row in rows
+            if str(row.get("type") or "").upper() == "N"
+            and str(row.get("exchange") or "").upper() == "A"
+            and row.get("ts_code")
+            and row.get("name")
+        ]
+        self.database.save_data_snapshot(
+            "theme_directory_v1", "ths", "market", {"items": items}
+        )
+        return items
+
+    def theme_library(self, requested_date: str, force: bool = False) -> dict[str, Any]:
+        trade_date, previous_date = self._trade_context(requested_date)
+        if not force:
+            cached = self.database.get_data_snapshot("theme_library_v1", trade_date)
+            if cached:
+                result = copy.deepcopy(cached)
+                result["meta"] = {**result.get("meta", {}), "cached": True}
+                return result
+
+        try:
+            daily = self.client.query(
+                "ths_daily",
+                {"trade_date": trade_date},
+                "ts_code,trade_date,open,high,low,close,pre_close,pct_change,vol,turnover_rate",
+            )
+        except TushareError:
+            fallback = self._latest_feature_snapshot("theme_library_v1", trade_date)
+            if fallback:
+                result = copy.deepcopy(fallback)
+                result["meta"] = {
+                    **result.get("meta", {}),
+                    "requested_date": _display_date(requested_date),
+                    "carried_forward": True,
+                    "cached": True,
+                    "notice": "当前题材行情暂不可用，展示最近有效快照",
+                }
+                return result
+            daily = []
+        actual_date = trade_date
+        carried_forward = False
+        if not daily and previous_date:
+            try:
+                daily = self.client.query(
+                    "ths_daily",
+                    {"trade_date": previous_date},
+                    "ts_code,trade_date,open,high,low,close,pre_close,pct_change,vol,turnover_rate",
+                )
+            except TushareError:
+                daily = []
+            actual_date = previous_date
+            carried_forward = bool(daily)
+        daily_map = {str(row.get("ts_code") or ""): row for row in daily}
+        try:
+            hot_rows = self.client.query("ths_hot", {"trade_date": actual_date})
+        except TushareError:
+            hot_rows = []
+        hot_map = {
+            str(row.get("ts_code") or ""): int(_number(row.get("rank")))
+            for row in hot_rows
+            if str(row.get("data_type") or "") == "概念板块"
+        }
+        items = []
+        for item in self._theme_directory():
+            quote = daily_map.get(item["code"], {})
+            items.append(
+                {
+                    **item,
+                    "change": round(_number(quote.get("pct_change")), 2),
+                    "close": round(_number(quote.get("close")), 3),
+                    "turnover_rate": round(_number(quote.get("turnover_rate")), 2),
+                    "volume": round(_number(quote.get("vol")), 2),
+                    "hot_rank": hot_map.get(item["code"]),
+                    "has_quote": bool(quote),
+                }
+            )
+        items.sort(
+            key=lambda item: (
+                item["has_quote"],
+                item["hot_rank"] is not None,
+                -(item["hot_rank"] or 9999),
+                item["change"],
+            ),
+            reverse=True,
+        )
+        quoted = [item for item in items if item["has_quote"]]
+        result = {
+            "meta": {
+                "requested_date": _display_date(requested_date),
+                "trade_date": _display_date(actual_date),
+                "carried_forward": carried_forward,
+                "cached": False,
+                "notice": "" if quoted else "该交易日暂无题材行情，已保留题材目录",
+                "updated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+            },
+            "summary": {
+                "theme_count": len(items),
+                "quoted_count": len(quoted),
+                "up_count": sum(item["change"] > 0 for item in quoted),
+                "down_count": sum(item["change"] < 0 for item in quoted),
+                "hot_count": len(hot_map),
+            },
+            "items": items,
+        }
+        self.database.save_data_snapshot("theme_library_v1", trade_date, "market", result)
+        return result
+
+    def theme_detail(self, code: str, requested_date: str) -> dict[str, Any]:
+        code = str(code or "").strip().upper()
+        library = self.theme_library(requested_date)
+        theme = next((item for item in library["items"] if item["code"] == code), None)
+        if not theme:
+            raise ValueError("未找到对应题材。")
+        actual_date = str(library["meta"]["trade_date"]).replace("-", "")
+        detail_key = f"{actual_date}:{code}"
+        cached_detail = self.database.get_data_snapshot("theme_detail_v1", detail_key)
+        if cached_detail:
+            return cached_detail
+        try:
+            members = self.client.query(
+                "ths_member", {"ts_code": code, "is_new": "Y"}, "ts_code,con_code,con_name"
+            )
+        except TushareError:
+            members = []
+        bars = self.database.daily_bars_for_date(actual_date)
+        if not bars:
+            bars = self.client.query(
+                "daily",
+                {"trade_date": actual_date},
+                "ts_code,trade_date,open,high,low,close,pct_chg,vol,amount",
+            )
+            self.database.upsert_daily_bars(bars)
+        bar_map = {str(row.get("ts_code") or ""): row for row in bars}
+        normalized_members = []
+        for member in members:
+            ts_code = str(member.get("con_code") or "")
+            quote = bar_map.get(ts_code, {})
+            normalized_members.append(
+                {
+                    "code": ts_code.split(".")[0],
+                    "ts_code": ts_code,
+                    "name": str(member.get("con_name") or "--"),
+                    "price": round(_number(quote.get("close")), 2),
+                    "change": round(_number(quote.get("pct_chg")), 2),
+                    "amount_billion": round(_number(quote.get("amount")) / 100_000, 2),
+                    "has_quote": bool(quote),
+                }
+            )
+        normalized_members.sort(
+            key=lambda item: (item["has_quote"], item["change"], item["amount_billion"]),
+            reverse=True,
+        )
+        end = datetime.strptime(actual_date, "%Y%m%d")
+        try:
+            history = self.client.query(
+                "ths_daily",
+                {
+                    "ts_code": code,
+                    "start_date": (end - timedelta(days=190)).strftime("%Y%m%d"),
+                    "end_date": actual_date,
+                },
+                "ts_code,trade_date,open,high,low,close,pct_change,vol,turnover_rate",
+            )
+        except TushareError:
+            history = []
+        history.sort(key=lambda row: str(row.get("trade_date") or ""))
+        series = [
+            {
+                "trade_date": _display_date(str(row.get("trade_date") or "")),
+                "open": _number(row.get("open")),
+                "high": _number(row.get("high")),
+                "low": _number(row.get("low")),
+                "close": _number(row.get("close")),
+                "change": _number(row.get("pct_change")),
+                "volume": _number(row.get("vol")),
+            }
+            for row in history[-90:]
+        ]
+        result = {
+            "meta": {
+                "trade_date": _display_date(actual_date),
+                "notice": "" if members or history else "题材成分与走势暂不可用",
+            },
+            "theme": theme,
+            "series": series,
+            "members": normalized_members,
+            "summary": {
+                "member_count": len(normalized_members),
+                "up_count": sum(item["change"] > 0 for item in normalized_members if item["has_quote"]),
+                "down_count": sum(item["change"] < 0 for item in normalized_members if item["has_quote"]),
+                "quoted_count": sum(item["has_quote"] for item in normalized_members),
+            },
+        }
+        if members or history:
+            self.database.save_data_snapshot("theme_detail_v1", detail_key, "market", result)
+        return result

app/backend/features/market/repository.py

@@ -6,6 +6,74 @@ from typing import Any
 
 
 class MarketRepositoryMixin:
+    def upsert_stock_master(self, rows: list[dict[str, Any]]) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        values = [
+            (
+                row.get("ts_code", ""),
+                str(row.get("ts_code", "")).split(".")[0],
+                row.get("name") or "--",
+                row.get("industry") or "",
+                row.get("market") or "",
+                str(row.get("list_date") or ""),
+                now,
+            )
+            for row in rows if row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO stock_master
+                    (ts_code, code, name, industry, market, list_date, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(ts_code) DO UPDATE SET
+                    code=excluded.code, name=excluded.name, industry=excluded.industry,
+                    market=excluded.market, list_date=excluded.list_date, updated_at=excluded.updated_at
+                """,
+                values,
+            )
+        return len(values)
+
+    def list_stock_master(self) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT ts_code, code, name, industry, market, list_date FROM stock_master"
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def upsert_daily_bars(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("trade_date") or ""), row.get("ts_code", ""),
+                float(row.get("open") or 0), float(row.get("high") or 0),
+                float(row.get("low") or 0), float(row.get("close") or 0),
+                float(row.get("pct_chg") or 0), float(row.get("vol") or 0),
+                float(row.get("amount") or 0),
+            )
+            for row in rows if row.get("trade_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO daily_bars
+                    (trade_date, ts_code, open, high, low, close, pct_chg, vol, amount)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    open=excluded.open, high=excluded.high, low=excluded.low,
+                    close=excluded.close, pct_chg=excluded.pct_chg,
+                    vol=excluded.vol, amount=excluded.amount
+                """,
+                values,
+            )
+        return len(values)
+
+    def daily_bars_for_date(self, trade_date: str) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT * FROM daily_bars WHERE trade_date = ? ORDER BY ts_code",
+                (trade_date,),
+            ).fetchall()
+        return [dict(row) for row in rows]
     def get_snapshot(self, trade_date: str) -> dict[str, Any] | None:
         with self.connect() as connection:
             row = connection.execute(

app/backend/features/market/routes.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+from backend.data.providers.tushare_client import TushareError
+from backend.features.market import ChartDataError
+
+
+class MarketRoutesMixin:
+    def _handle_market_get(self, parsed) -> bool:
+        if parsed.path == "/api/dashboard":
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            try:
+                self.send_json(self.application_service.get_dashboard(trade_date, False))
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            except Exception as exc:
+                self.send_json({"error": f"数据加载失败：{exc}"}, HTTPStatus.INTERNAL_SERVER_ERROR)
+            return True
+        if parsed.path == "/api/realtime-aggregate/health":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    {
+                        "ok": True,
+                        "aggregate": self.application_service.realtime_aggregate_health(
+                            query.get("sector", [""])[0]
+                        ),
+                    }
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/search":
+            query = parse_qs(parsed.query)
+            search_query = query.get("q", [""])[0]
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            try:
+                self.send_json(self.application_service.search_entities(search_query, trade_date))
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/search/detail":
+            query = parse_qs(parsed.query)
+            entity_type = query.get("type", [""])[0]
+            identifier = query.get("id", [""])[0]
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            try:
+                self.send_json(
+                    self.application_service.get_search_detail(entity_type, identifier, trade_date)
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            except TushareError as exc:
+                self.send_json({"error": f"行情加载失败：{exc}"}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/chart/intraday":
+            query = parse_qs(parsed.query)
+            entity_type = query.get("type", [""])[0]
+            identifier = query.get("id", [""])[0]
+            try:
+                self.send_json(self.application_service.get_intraday_chart(entity_type, identifier))
+            except (ValueError, ChartDataError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        stock_preview_match = re.fullmatch(r"/api/stock/(\d{6})/preview", parsed.path)
+        if stock_preview_match:
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            force = query.get("force", ["0"])[0] == "1"
+            try:
+                self.send_json(
+                    self.application_service.get_stock_preview(stock_preview_match.group(1), trade_date, force)
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        stock_match = re.fullmatch(r"/api/stock/(\d{6})", parsed.path)
+        if stock_match:
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            force = query.get("force", ["0"])[0] == "1"
+            try:
+                self.send_json(self.application_service.get_stock_detail(stock_match.group(1), trade_date, force))
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False

app/backend/features/market/service.py

@@ -14,7 +14,8 @@ from backend.bootstrap.config import (
 from backend.data.providers.ifind_client import IfindError
 from backend.data.providers.tushare_client import TushareClient, TushareError
 from backend.features.market.charts import ChartDataError
-from sentiment_engine import SENTIMENT_ENGINE_VERSION
+from backend.features.market.insights import MarketInsightsService
+from backend.features.sentiment.engine import SENTIMENT_ENGINE_VERSION
 
 
 SEARCH_INDEXES = (
@@ -36,6 +37,14 @@ THS_SEARCH_TYPES = {
 
 
 class MarketServiceMixin:
+    def _market_insights(self) -> MarketInsightsService:
+        if not self.configured:
+            raise ValueError("行情数据尚未配置。")
+        return MarketInsightsService(
+            self.database,
+            self._tushare_client(),
+            ifind=self.ifind,
+        )
     def _tushare_client(self) -> TushareClient:
         gateway = getattr(self, "data_gateway", None)
         if gateway is not None:

app/backend/features/mentor/__init__.py

@@ -0,0 +1,21 @@
+from .agent import (
+    MentorAgentError,
+    MentorSkill,
+    MentorSkillRegistry,
+    chat_with_mentor,
+    stream_with_mentor,
+)
+from .http import MentorHttpMixin
+from .repository import MentorRepositoryMixin
+from .service import MentorServiceMixin
+
+__all__ = [
+    "MentorAgentError",
+    "MentorHttpMixin",
+    "MentorRepositoryMixin",
+    "MentorServiceMixin",
+    "MentorSkill",
+    "MentorSkillRegistry",
+    "chat_with_mentor",
+    "stream_with_mentor",
+]

app/backend/features/mentor/agent.py

@@ -3,20 +3,23 @@ from __future__ import annotations
 import json
 import re
 import time
-import urllib.error
-import urllib.request
 from collections.abc import Iterator
 from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
-from llm_stream import OpenAIStreamAccumulator
+from backend.llm import transport as llm_transport
 
 
 class MentorAgentError(RuntimeError):
     pass
 
 
+FOLLOW_UP_START = "<XIAOBAI_FOLLOW_UPS>"
+FOLLOW_UP_END = "</XIAOBAI_FOLLOW_UPS>"
+MAX_FOLLOW_UP_LENGTH = 80
+
+
 @dataclass(frozen=True)
 class MentorSkill:
     skill_id: str
@@ -187,6 +190,8 @@ def stream_with_mentor(
     base_url: str,
     model: str,
     timeout: int = 90,
+    *,
+    follow_ups: list[str] | None = None,
 ) -> Iterator[str]:
     if not api_key or not model:
         raise MentorAgentError("LLM API Key 或模型尚未配置。")
@@ -195,50 +200,23 @@ def stream_with_mentor(
     messages = [{"role": "system", "content": system_prompt}]
     messages.extend(history[-10:])
     messages.append({"role": "user", "content": question})
-    payload = json.dumps(
-        {"model": model, "messages": messages, "stream": True},
-        ensure_ascii=False,
-    ).encode("utf-8")
-    request = urllib.request.Request(
-        f"{base_url.rstrip('/')}/chat/completions",
-        data=payload,
-        headers={
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}",
-            "User-Agent": "XiaobaiReviewWeb/0.6",
-            "Accept": "text/event-stream",
-        },
-        method="POST",
-    )
+    if follow_ups is not None:
+        follow_ups.clear()
     try:
-        with urllib.request.urlopen(request, timeout=timeout) as response:
-            yielded = False
-            accumulator = OpenAIStreamAccumulator()
-            for raw_line in response:
-                line = raw_line.decode("utf-8", errors="replace").strip()
-                if not line or line.startswith(":"):
-                    continue
-                if line.startswith("data:"):
-                    line = line[5:].strip()
-                if line == "[DONE]":
-                    break
-                try:
-                    result = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-                choices = result.get("choices") or []
-                if not choices:
-                    continue
-                choice = choices[0] or {}
-                content = accumulator.feed(choice)
-                if content:
-                    yielded = True
-                    yield str(content)
-            if not yielded:
-                raise MentorAgentError("问师模型未返回有效内容。")
-    except urllib.error.HTTPError as exc:
-        raise MentorAgentError(_http_error_message(exc)) from exc
-    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+        upstream = llm_transport.stream_chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=messages,
+            timeout=timeout,
+            user_agent="XiaobaiReviewWeb/0.6",
+        )
+        yield from _stream_answer_and_collect_follow_ups(upstream, follow_ups)
+    except llm_transport.OpenAIEmptyResponseError as exc:
+        raise MentorAgentError("问师模型未返回有效内容。") from exc
+    except llm_transport.OpenAIHTTPError as exc:
+        raise MentorAgentError(exc.describe("问师模型调用失败")) from exc
+    except llm_transport.OpenAITransportError as exc:
         raise MentorAgentError(f"问师模型调用失败：{exc}") from exc
 
 
@@ -255,6 +233,10 @@ def _build_system_prompt(skill: MentorSkill, market_context: dict[str, Any]) ->
 5. 优先回答用户真正的问题。市场分析通常按“判断、数据依据、思维模型下的应对、失效条件”组织；纯交易心理或方法问题可以自然回答，不强制套模板。
 6. 保留该 Skill 的核心心智模型和表达节奏，但不要复述身份履历，不要宣称自己就是真人，不攻击或贬低用户。
 7. 使用中文，信息密度高，避免空泛口号。引用数字时标明数据日期。
+8. 正文结束后必须输出2至3条与本轮问题和正文直接相关的追问。追问用于帮助用户继续核实条件、风险或失效边界，不得引入正文没有依据的新事实，不得给出无条件买卖指令。严格使用以下机器结构，不要放进Markdown代码块，结束标签后不要再输出文字：
+<XIAOBAI_FOLLOW_UPS>
+["追问一？","追问二？","追问三？"]
+</XIAOBAI_FOLLOW_UPS>
 
 网页市场数据：
 {context_json}
@@ -265,6 +247,67 @@ def _build_system_prompt(skill: MentorSkill, market_context: dict[str, Any]) ->
 """.strip()
 
 
+def _stream_answer_and_collect_follow_ups(
+    chunks: Iterator[str], follow_ups: list[str] | None
+) -> Iterator[str]:
+    buffer = ""
+    collecting = False
+    for raw_chunk in chunks:
+        chunk = str(raw_chunk or "")
+        if not chunk:
+            continue
+        buffer += chunk
+        if collecting:
+            continue
+        marker_index = buffer.find(FOLLOW_UP_START)
+        if marker_index >= 0:
+            if marker_index:
+                yield buffer[:marker_index]
+            buffer = buffer[marker_index + len(FOLLOW_UP_START):]
+            collecting = True
+            continue
+        overlap = _marker_prefix_overlap(buffer, FOLLOW_UP_START)
+        emit_length = len(buffer) - overlap
+        if emit_length:
+            yield buffer[:emit_length]
+            buffer = buffer[emit_length:]
+
+    if not collecting:
+        if buffer:
+            yield buffer
+        return
+    raw_follow_ups = buffer.split(FOLLOW_UP_END, 1)[0].strip()
+    parsed = _parse_follow_ups(raw_follow_ups)
+    if follow_ups is not None and len(parsed) >= 2:
+        follow_ups.extend(parsed)
+
+
+def _marker_prefix_overlap(value: str, marker: str) -> int:
+    max_length = min(len(value), len(marker) - 1)
+    for length in range(max_length, 0, -1):
+        if value.endswith(marker[:length]):
+            return length
+    return 0
+
+
+def _parse_follow_ups(payload: str) -> list[str]:
+    try:
+        values = json.loads(payload)
+    except (TypeError, json.JSONDecodeError):
+        return []
+    if not isinstance(values, list):
+        return []
+    result: list[str] = []
+    for value in values:
+        question = re.sub(r"\s+", " ", str(value or "")).strip()
+        if not question or len(question) > MAX_FOLLOW_UP_LENGTH or question in result:
+            continue
+        result.append(question)
+        if len(result) == 3:
+            break
+    return result
+
+
 def _parse_frontmatter(content: str) -> dict[str, str]:
     if not content.startswith("---"):
         return {}
@@ -298,20 +341,3 @@ def _parse_frontmatter(content: str) -> dict[str, str]:
 def _first_sentence(text: str) -> str:
     compact = " ".join(line.strip() for line in text.splitlines() if line.strip())
     return re.split(r"[。；]", compact, maxsplit=1)[0].strip()
-
-
-def _http_error_message(exc: urllib.error.HTTPError) -> str:
-    detail = ""
-    try:
-        payload = json.loads(exc.read().decode("utf-8", errors="replace"))
-        error = payload.get("error")
-        if isinstance(error, dict):
-            detail = str(error.get("message") or error.get("code") or "")
-        elif error:
-            detail = str(error)
-        elif payload.get("message"):
-            detail = str(payload["message"])
-    except (json.JSONDecodeError, OSError):
-        detail = ""
-    suffix = f"：{detail[:300]}" if detail else ""
-    return f"问师模型调用失败（HTTP {exc.code}）{suffix}"

app/backend/features/mentor/http.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import json
+from http import HTTPStatus
+
+from backend.features.mentor.agent import MentorAgentError
+
+
+class MentorHttpMixin:
+    def stream_mentor_chat(self) -> None:
+        try:
+            body = self.read_json_body()
+            stream = self.application_service.mentor_stream(body)
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return
+        self.send_ndjson_stream(stream, (ValueError, MentorAgentError))

app/backend/features/mentor/repository.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+
+class MentorRepositoryMixin:
+    def save_mentor_exchange(
+        self,
+        user_id: int,
+        mentor_id: str,
+        trade_date: str,
+        question: str,
+        answer: str,
+        meta: str = "",
+    ) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO mentor_messages
+                    (user_id, mentor_id, trade_date, role, content, meta, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                """,
+                [
+                    (int(user_id), mentor_id, trade_date, "user", question, "", now),
+                    (int(user_id), mentor_id, trade_date, "assistant", answer, meta, now),
+                ],
+            )
+            connection.execute(
+                """
+                DELETE FROM mentor_messages
+                WHERE user_id = ? AND id NOT IN (
+                    SELECT id FROM mentor_messages WHERE user_id = ? ORDER BY id DESC LIMIT 500
+                )
+                """,
+                (int(user_id), int(user_id)),
+            )
+
+    def list_mentor_messages(
+        self, user_id: int, mentor_id: str, trade_date: str, limit: int = 100
+    ) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT role, content, meta, created_at FROM mentor_messages
+                WHERE user_id = ? AND mentor_id = ? AND trade_date = ?
+                ORDER BY id DESC LIMIT ?
+                """,
+                (int(user_id), mentor_id, trade_date, max(1, min(500, int(limit)))),
+            ).fetchall()
+        return [dict(row) for row in reversed(rows)]
+
+    def delete_mentor_messages(self, user_id: int, mentor_id: str, trade_date: str) -> int:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM mentor_messages WHERE user_id = ? AND mentor_id = ? AND trade_date = ?",
+                (int(user_id), mentor_id, trade_date),
+            )
+            return int(cursor.rowcount)
+
+    def list_mentor_preferences(self, user_id: int) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT mentor_id, pinned, sort_order
+                FROM mentor_preferences
+                WHERE user_id = ?
+                ORDER BY sort_order, mentor_id
+                """,
+                (int(user_id),),
+            ).fetchall()
+        return [
+            {
+                "mentor_id": str(row["mentor_id"]),
+                "pinned": bool(row["pinned"]),
+                "sort_order": int(row["sort_order"]),
+            }
+            for row in rows
+        ]
+
+    def save_mentor_preferences(
+        self, user_id: int, ordered_ids: list[str], pinned_ids: set[str]
+    ) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        values = [
+            (int(user_id), mentor_id, int(mentor_id in pinned_ids), index, now)
+            for index, mentor_id in enumerate(ordered_ids)
+        ]
+        with self.connect() as connection:
+            connection.execute(
+                "DELETE FROM mentor_preferences WHERE user_id = ?",
+                (int(user_id),),
+            )
+            connection.executemany(
+                """
+                INSERT INTO mentor_preferences
+                    (user_id, mentor_id, pinned, sort_order, updated_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                values,
+            )

app/backend/features/mentor/routes.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+
+
+class MentorRoutesMixin:
+    def _handle_mentor_get(self, parsed) -> bool:
+        if parsed.path == "/api/mentors/setup":
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            try:
+                self.send_json(self.application_service.mentor_setup(trade_date))
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/mentors/messages":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    {
+                        "items": self.application_service.mentor_messages(
+                            query.get("mentor_id", [""])[0],
+                            query.get("trade_date", [date.today().isoformat()])[0],
+                        )
+                    }
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False
+
+    def _handle_mentor_post(self, parsed) -> bool:
+        if parsed.path == "/api/mentors/preferences":
+            try:
+                result = self.application_service.save_mentor_preferences(self.read_json_body())
+                self.send_json({"ok": True, **result})
+            except (ValueError, json.JSONDecodeError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False
+
+    def _handle_mentor_delete(self, parsed) -> bool:
+        if parsed.path == "/api/mentors/messages":
+            query = parse_qs(parsed.query)
+            try:
+                deleted = self.application_service.clear_mentor_messages(
+                    query.get("mentor_id", [""])[0],
+                    query.get("trade_date", [date.today().isoformat()])[0],
+                )
+                self.send_json({"ok": True, "deleted": deleted})
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False

app/backend/features/mentor/service.py

@@ -0,0 +1,480 @@
+from __future__ import annotations
+
+import re
+from datetime import date, datetime, timedelta
+from typing import Any
+
+from backend.bootstrap.config import normalize_date, validate_text
+from backend.data.providers.ifind_client import IfindError
+from backend.features.mentor.agent import MentorAgentError, stream_with_mentor
+
+
+MENTOR_DATA_PROFILES = {
+    "emotion": {
+        "kobe92-perspective", "niepanchongsheng-perspective",
+        "chaojiyangjia-perspective", "tuixuechaogu-perspective",
+        "chenxiaoqun-perspective", "zhiyechaoshou-perspective",
+    },
+    "first_board": {
+        "beijingchaojia-perspective", "chuangshiji-perspective",
+        "xuxiang-perspective", "foshanwuyingjiao-perspective",
+    },
+    "leader": {
+        "zhaolaoge-perspective", "fangxinxia-perspective",
+        "xiaoe-perspective", "sunge-perspective", "liuyizhonglu-perspective",
+    },
+    "trend": {
+        "zhangdetao-perspective", "zhangmengzhu-perspective",
+        "zuoshouxinyi-perspective",
+    },
+    "low_absorption": {
+        "qiaobangzhu-perspective", "asking-perspective",
+        "longfeihu-perspective", "ruihexian-perspective",
+    },
+    "macro": {"shuipi-perspective"},
+}
+
+MENTOR_INDEX_UNIVERSE = (
+    ("000001.SH", "上证指数"), ("399001.SZ", "深证成指"),
+    ("399006.SZ", "创业板指"), ("000016.SH", "上证50"),
+    ("000300.SH", "沪深300"), ("000905.SH", "中证500"),
+    ("000852.SH", "中证1000"), ("932000.CSI", "中证2000"),
+)
+
+MENTOR_ETF_UNIVERSE = (
+    ("510050.SH", "上证50ETF"), ("510300.SH", "沪深300ETF"),
+    ("510500.SH", "中证500ETF"), ("512100.SH", "中证1000ETF"),
+)
+
+
+class MentorServiceMixin:
+    def mentor_setup(self, trade_date: str) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        mentors = [
+            skill.public()
+            for skill in self.mentor_skills.list_skills(
+                include_private=self.membership()["is_admin"]
+            )
+        ]
+        if not mentors:
+            raise ValueError("游资skills 目录中没有可用的 SKILL.md。")
+        stored_preferences = self.database.list_mentor_preferences(self.current_user_id)
+        preferences = {item["mentor_id"]: item for item in stored_preferences}
+        for default_order, mentor in enumerate(mentors):
+            preference = preferences.get(str(mentor.get("id") or ""), {})
+            mentor["pinned"] = bool(preference.get("pinned"))
+            mentor["sort_order"] = int(preference.get("sort_order", 10000 + default_order))
+        mentors.sort(
+            key=lambda item: (
+                not bool(item.get("pinned")),
+                int(item.get("sort_order") or 0),
+            )
+        )
+        for sort_order, mentor in enumerate(mentors):
+            mentor["sort_order"] = sort_order
+        snapshot = self.database.get_snapshot(normalized_date)
+        actual_date = str((snapshot or {}).get("meta", {}).get("trade_date") or normalized_date)
+        return {
+            "trade_date": actual_date,
+            "mentors": mentors,
+            "preferences_configured": bool(stored_preferences),
+            "llm": {
+                "configured": self.llm_configured,
+                "model": self.llm_primary_model if self.llm_configured else "",
+                "fallback_configured": self.llm_fallback_configured,
+                "fallback_model": self.llm_fallback_model if self.llm_fallback_configured else "",
+            },
+        }
+
+    def save_mentor_preferences(self, payload: dict[str, Any]) -> dict[str, Any]:
+        available_ids = [
+            skill.skill_id
+            for skill in self.mentor_skills.list_skills(
+                include_private=self.membership()["is_admin"]
+            )
+        ]
+        available = set(available_ids)
+        raw_order = payload.get("order")
+        raw_pinned = payload.get("pinned")
+        if not isinstance(raw_order, list) or not isinstance(raw_pinned, list):
+            raise ValueError("问师排序格式不正确。")
+        ordered_ids: list[str] = []
+        for raw_id in raw_order:
+            mentor_id = validate_text(raw_id, "问师角色", 100, required=True)
+            if mentor_id not in available:
+                raise ValueError("问师排序中包含不可用的思维模型。")
+            if mentor_id not in ordered_ids:
+                ordered_ids.append(mentor_id)
+        ordered_ids.extend(mentor_id for mentor_id in available_ids if mentor_id not in ordered_ids)
+        pinned_ids = {
+            validate_text(raw_id, "问师角色", 100, required=True)
+            for raw_id in raw_pinned
+        }
+        if not pinned_ids.issubset(available):
+            raise ValueError("问师置顶中包含不可用的思维模型。")
+        self.database.save_mentor_preferences(
+            self.current_user_id, ordered_ids, pinned_ids
+        )
+        return {"saved": True}
+
+    def mentor_stream(self, payload: dict[str, Any]):
+        mentor_id = validate_text(payload.get("mentor_id"), "问师角色", 100, required=True)
+        question = validate_text(payload.get("question"), "问题", 2000, required=True)
+        trade_date = normalize_date(str(payload.get("trade_date") or date.today().isoformat()))
+        history = self._validate_mentor_history(payload.get("history") or [])
+        skill = self.mentor_skills.get_skill(
+            mentor_id, include_private=self.membership()["is_admin"]
+        )
+        context = self._build_mentor_context(trade_date, question, skill)
+
+        def generate():
+            answer_parts: list[str] = []
+            follow_ups: list[str] = []
+            events = self.llm_gateway.stream(
+                "mentor",
+                f"mentor-skill-v2:{skill.skill_id}",
+                lambda profile: stream_with_mentor(
+                    skill,
+                    context,
+                    question,
+                    history,
+                    profile.api_key,
+                    profile.base_url,
+                    profile.model,
+                    follow_ups=follow_ups,
+                ),
+                (MentorAgentError,),
+            )
+            for event in events:
+                if event.kind == "delta":
+                    chunk = str(event.value or "")
+                    answer_parts.append(chunk)
+                    yield {"type": "delta", "content": chunk}
+                elif event.kind == "complete":
+                    self.database.save_mentor_exchange(
+                        self.current_user_id,
+                        mentor_id,
+                        trade_date,
+                        question,
+                        "".join(answer_parts).strip(),
+                        context["data_trade_date"],
+                    )
+                    yield {
+                        "type": "meta",
+                        "data_trade_date": context["data_trade_date"],
+                        "follow_ups": follow_ups or self._mentor_follow_up_fallback(question),
+                        "notice": "智能解读已自动切换可用服务。"
+                        if event.role == "fallback"
+                        else "",
+                    }
+
+        return generate()
+
+    @staticmethod
+    def _mentor_follow_up_fallback(question: str) -> list[str]:
+        normalized = question.strip()
+        if any(keyword in normalized for keyword in ("风险", "亏损", "回撤", "止损")):
+            return [
+                "这些风险最早会从哪些信号中暴露？",
+                "哪些变化会让当前风险判断失效？",
+                "如果风险继续扩大，仓位预案应如何调整？",
+            ]
+        if any(keyword in normalized for keyword in ("股票", "个股", "代码", "怎么看")):
+            return [
+                "这个判断最关键的确认信号是什么？",
+                "哪些变化会让当前结论失效？",
+                "明日盘中应该优先观察哪些数据？",
+            ]
+        return [
+            "这个判断最关键的确认依据是什么？",
+            "哪些变化会让当前结论失效？",
+            "下一步应该优先观察什么？",
+        ]
+
+    def mentor_messages(self, mentor_id: str, trade_date: str) -> list[dict[str, Any]]:
+        mentor_id = validate_text(mentor_id, "问师角色", 100, required=True)
+        trade_date = normalize_date(trade_date)
+        self.mentor_skills.get_skill(
+            mentor_id, include_private=self.membership()["is_admin"]
+        )
+        return self.database.list_mentor_messages(
+            self.current_user_id, mentor_id, trade_date
+        )
+
+    def clear_mentor_messages(self, mentor_id: str, trade_date: str) -> int:
+        mentor_id = validate_text(mentor_id, "问师角色", 100, required=True)
+        trade_date = normalize_date(trade_date)
+        self.mentor_skills.get_skill(
+            mentor_id, include_private=self.membership()["is_admin"]
+        )
+        return self.database.delete_mentor_messages(
+            self.current_user_id, mentor_id, trade_date
+        )
+
+    @staticmethod
+    def _validate_mentor_history(raw_history: Any) -> list[dict[str, str]]:
+        if not isinstance(raw_history, list):
+            raise ValueError("问师对话历史格式不正确。")
+        history = []
+        total_length = 0
+        for item in raw_history[-12:]:
+            if not isinstance(item, dict) or item.get("role") not in {"user", "assistant"}:
+                raise ValueError("问师对话历史包含无效消息。")
+            content = str(item.get("content") or "").strip()
+            if not content or len(content) > 5000:
+                raise ValueError("问师对话历史消息为空或过长。")
+            total_length += len(content)
+            if total_length > 24_000:
+                raise ValueError("问师对话历史过长，请清空后重新提问。")
+            history.append({"role": item["role"], "content": content})
+        return history
+
+    def _build_mentor_context(
+        self, trade_date: str, question: str, skill: Any | None = None
+    ) -> dict[str, Any]:
+        dashboard = self.get_dashboard(trade_date)
+        data_trade_date = normalize_date(
+            str(dashboard.get("meta", {}).get("trade_date") or trade_date)
+        )
+        regime = self.screener.detect_regime(data_trade_date)
+        limits = list(dashboard.get("limits") or [])
+        broken = list(dashboard.get("broken") or [])
+        down_limits = list(dashboard.get("down_limits") or [])
+        yesterday_limits = list(dashboard.get("yesterday_limits") or [])
+        all_stocks = limits + broken + down_limits + yesterday_limits
+        matched_rows = []
+        codes = re.findall(r"(?<!\d)\d{6}(?!\d)", question)[:3]
+        for row in all_stocks:
+            code = str(row.get("code") or "")
+            name = str(row.get("name") or "")
+            if code in codes or (len(name) >= 2 and name in question):
+                if not any(item.get("code") == code for item in matched_rows):
+                    matched_rows.append(row)
+        for row in matched_rows:
+            code = str(row.get("code") or "")
+            if code and code not in codes:
+                codes.append(code)
+        stock_details = []
+        for code in codes[:2]:
+            try:
+                detail = self.get_stock_detail(code, data_trade_date)
+                stock_details.append(
+                    {
+                        "stock": detail.get("stock") or {},
+                        "moneyflow": detail.get("moneyflow") or {},
+                        "recent_prices": (detail.get("prices") or [])[-20:],
+                    }
+                )
+            except Exception as exc:
+                stock_details.append({"code": code, "error": str(exc)})
+
+        skill_id = str(getattr(skill, "skill_id", "") or "")
+        profile = next(
+            (
+                profile_name
+                for profile_name, skill_ids in MENTOR_DATA_PROFILES.items()
+                if skill_id in skill_ids
+            ),
+            "balanced",
+        )
+        dragon_tiger = None
+        if any(keyword in question for keyword in ("龙虎榜", "席位", "机构", "游资")):
+            try:
+                dragon_payload = self.get_dragon_tiger(data_trade_date)
+                rows = list(dragon_payload.get("rows") or [])
+                matched_dragon = [row for row in rows if str(row.get("code") or "") in codes]
+                leading_dragon = sorted(
+                    rows,
+                    key=lambda row: abs(float(row.get("net_buy_million") or 0)),
+                    reverse=True,
+                )[:12]
+                dragon_tiger = {
+                    "summary": dragon_payload.get("summary") or {},
+                    "matched": matched_dragon,
+                    "largest_net_flows": leading_dragon,
+                }
+            except Exception as exc:
+                dragon_tiger = {"error": str(exc)}
+
+        context: dict[str, Any] = {
+            "data_trade_date": data_trade_date,
+            "data_profile": profile,
+            "overview": dashboard.get("overview") or {},
+            "market_regime": regime,
+            "recent_market_history": self.database.snapshot_summaries(data_trade_date, 10),
+            "question_matched_stocks": matched_rows[:10],
+            "stock_details": stock_details,
+        }
+
+        ordered_limits = sorted(
+            limits,
+            key=lambda row: (
+                float(row.get("streak") or 0),
+                float(row.get("amount_billion") or 0),
+            ),
+            reverse=True,
+        )
+        if profile in {"emotion", "balanced"}:
+            context.update(
+                {
+                    "limit_ladder": dashboard.get("ladders") or [],
+                    "limit_performance": dashboard.get("limit_performance") or [],
+                    "hot_sectors": (dashboard.get("sectors") or [])[:15],
+                    "sector_rotation": (dashboard.get("sector_rotation") or [])[:15],
+                    "limit_up_stocks": ordered_limits[:30],
+                    "broken_stocks": sorted(
+                        broken,
+                        key=lambda row: float(row.get("amount_billion") or 0),
+                        reverse=True,
+                    )[:20],
+                    "limit_down_stocks": down_limits[:20],
+                    "yesterday_limit_performance": sorted(
+                        yesterday_limits,
+                        key=lambda row: float(row.get("change") or 0),
+                        reverse=True,
+                    )[:20],
+                }
+            )
+        elif profile == "first_board":
+            context.update(
+                {
+                    "first_board_environment": {
+                        "seal_rate": (dashboard.get("overview") or {}).get("seal_rate"),
+                        "broken_count": len(broken),
+                        "first_boards": [row for row in ordered_limits if int(row.get("streak") or 1) == 1][:35],
+                        "broken_stocks": sorted(
+                            broken,
+                            key=lambda row: float(row.get("amount_billion") or 0),
+                            reverse=True,
+                        )[:30],
+                    },
+                    "hot_sectors": (dashboard.get("sectors") or [])[:12],
+                }
+            )
+        elif profile == "leader":
+            context.update(
+                {
+                    "limit_ladder": dashboard.get("ladders") or [],
+                    "multi_board_leaders": [
+                        row for row in ordered_limits if int(row.get("streak") or 0) >= 2
+                    ][:25],
+                    "hot_sectors": (dashboard.get("sectors") or [])[:12],
+                    "sector_rotation": (dashboard.get("sector_rotation") or [])[:12],
+                }
+            )
+            try:
+                popularity = self.popularity(data_trade_date)
+                context["popularity_core"] = {
+                    "consensus": [
+                        row for row in (popularity.get("combined") or [])
+                        if row.get("dual_source")
+                    ][:10],
+                    "ths": (popularity.get("ths") or [])[:10],
+                    "eastmoney": (popularity.get("dc") or [])[:10],
+                }
+            except Exception:
+                context["popularity_core"] = {"unavailable": True}
+        elif profile == "trend":
+            context.update(
+                {
+                    "index_momentum": self._mentor_market_matrix(
+                        data_trade_date, MENTOR_INDEX_UNIVERSE
+                    ),
+                    "sector_rotation": (dashboard.get("sector_rotation") or [])[:20],
+                    "hot_sectors": (dashboard.get("sectors") or [])[:20],
+                    "market_breadth": {
+                        key: (dashboard.get("overview") or {}).get(key)
+                        for key in ("up_count", "down_count", "flat_count", "amount_billion")
+                    },
+                }
+            )
+        elif profile == "low_absorption":
+            context.update(
+                {
+                    "yesterday_limit_performance": sorted(
+                        yesterday_limits,
+                        key=lambda row: float(row.get("change") or 0),
+                        reverse=True,
+                    )[:35],
+                    "broken_stocks": broken[:20],
+                    "hot_sectors": (dashboard.get("sectors") or [])[:12],
+                }
+            )
+        elif profile == "macro":
+            context.update(
+                {
+                    "broad_indexes": self._mentor_market_matrix(
+                        data_trade_date, MENTOR_INDEX_UNIVERSE
+                    ),
+                    "core_etfs": self._mentor_market_matrix(
+                        data_trade_date, MENTOR_ETF_UNIVERSE
+                    ),
+                    "market_style": {
+                        "amount_billion": (dashboard.get("overview") or {}).get("amount_billion"),
+                        "breadth": {
+                            "up": (dashboard.get("overview") or {}).get("up_count"),
+                            "down": (dashboard.get("overview") or {}).get("down_count"),
+                        },
+                        "top_sectors": (dashboard.get("sectors") or [])[:15],
+                    },
+                    "unavailable_data": [
+                        "政策原文与隔夜资讯尚未接入",
+                        "汇率、利率和商品宏观序列当前不可用",
+                    ],
+                }
+            )
+        if dragon_tiger is not None:
+            context["dragon_tiger"] = dragon_tiger
+        return context
+
+    def _mentor_market_matrix(
+        self, trade_date: str, universe: tuple[tuple[str, str], ...]
+    ) -> list[dict[str, Any]]:
+        ifind = getattr(self, "ifind", None)
+        if not ifind or not ifind.configured:
+            return []
+        end = datetime.strptime(trade_date, "%Y%m%d")
+        start = (end - timedelta(days=45)).strftime("%Y%m%d")
+        names = {code: name for code, name in universe}
+        try:
+            rows = ifind.history(
+                list(names), ["close", "volume", "amount"], start, trade_date, cache_ttl=600
+            )
+        except IfindError:
+            return []
+        grouped: dict[str, list[dict[str, Any]]] = {}
+        for row in rows:
+            code = str(row.get("thscode") or "").upper()
+            if code in names:
+                grouped.setdefault(code, []).append(row)
+        result = []
+        for code, name in universe:
+            series = sorted(grouped.get(code, []), key=lambda row: str(row.get("time") or ""))
+            closes = []
+            for row in series:
+                try:
+                    close = float(row.get("close") or 0)
+                except (TypeError, ValueError):
+                    continue
+                if close > 0:
+                    closes.append(close)
+            if not closes:
+                continue
+            def period_return(days: int) -> float | None:
+                if len(closes) <= days or closes[-days - 1] <= 0:
+                    return None
+                return round((closes[-1] / closes[-days - 1] - 1) * 100, 2)
+            previous = closes[-2] if len(closes) > 1 else 0
+            result.append(
+                {
+                    "code": code,
+                    "name": name,
+                    "close": round(closes[-1], 3),
+                    "change": round((closes[-1] / previous - 1) * 100, 2) if previous else None,
+                    "return_5d": period_return(5),
+                    "return_10d": period_return(10),
+                    "return_20d": period_return(20),
+                    "latest_amount": series[-1].get("amount") if series else None,
+                }
+            )
+        return result

app/backend/features/pools/__init__.py

@@ -0,0 +1,6 @@
+"""Limit-up, broken-board, limit-down and prior-limit pool feature."""
+
+from .repository import PoolRepositoryMixin
+from .service import PoolServiceMixin
+
+__all__ = ["PoolRepositoryMixin", "PoolServiceMixin"]

app/backend/features/pools/repository.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from datetime import datetime
+
+
+class PoolRepositoryMixin:
+    def save_reason_override(self, trade_date: str, code: str, reason: str) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.execute(
+                """
+                INSERT INTO reason_overrides (trade_date, code, reason, updated_at)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(trade_date, code) DO UPDATE SET
+                    reason = excluded.reason,
+                    updated_at = excluded.updated_at
+                """,
+                (trade_date, code, reason, now),
+            )
+
+    def reason_overrides(self, trade_date: str) -> dict[str, str]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT code, reason FROM reason_overrides WHERE trade_date = ?",
+                (trade_date,),
+            ).fetchall()
+        return {row["code"]: row["reason"] for row in rows}

app/backend/features/pools/routes.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import json
+from http import HTTPStatus
+
+
+class PoolRoutesMixin:
+    def save_reason(self) -> None:
+        try:
+            body = self.read_json_body()
+            self.application_service.save_reason(
+                str(body.get("trade_date") or ""),
+                str(body.get("code") or ""),
+                str(body.get("reason") or ""),
+            )
+            self.send_json({"ok": True})
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/pools/service.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import re
+from datetime import datetime, time as dt_time
+from typing import Any
+
+from backend.bootstrap.config import normalize_date, validate_stock_code
+from backend.data.providers.ifind_client import IfindError
+
+
+class PoolServiceMixin:
+    def save_reason(self, trade_date: str, code: str, reason: str) -> None:
+        normalized_date = normalize_date(trade_date)
+        code = validate_stock_code(code)
+        reason = reason.strip()
+        if not reason or len(reason) > 200:
+            raise ValueError("涨停原因应为 1 至 200 个字符。")
+        self.database.save_reason_override(normalized_date, code, reason)
+
+    def _apply_reason_overrides(self, dashboard: dict[str, Any]) -> dict[str, Any]:
+        trade_date = str(dashboard.get("meta", {}).get("trade_date", "")).replace("-", "")
+        enrichment = self.database.get_data_snapshot("ifind_event_enrichment_v1", trade_date)
+        if enrichment:
+            self._merge_ifind_event_enrichment(dashboard, enrichment)
+        else:
+            self._schedule_ifind_event_enrichment(trade_date)
+        overrides = self.database.reason_overrides(trade_date)
+        if not overrides:
+            return dashboard
+        for key in ("limits", "broken", "down_limits"):
+            for row in dashboard.get(key) or []:
+                if row.get("code") in overrides:
+                    row["reason"] = overrides[row["code"]]
+                    row["reason_source"] = "manual"
+        return dashboard
+
+    def _schedule_ifind_event_enrichment(self, trade_date: str) -> None:
+        ifind = getattr(self, "ifind", None)
+        if not ifind or not ifind.configured or not re.fullmatch(r"\d{8}", trade_date):
+            return
+        now = datetime.now().astimezone()
+        if trade_date == now.strftime("%Y%m%d") and now.time().replace(tzinfo=None) < dt_time(15, 0):
+            return
+        self.jobs.submit(
+            "market.ifind-event-enrichment",
+            f"{trade_date}:v1",
+            lambda: self._refresh_ifind_event_enrichment(trade_date),
+            {"trade_date": trade_date, "trigger": "dashboard-enrichment"},
+        )
+
+    def _refresh_ifind_event_enrichment(self, trade_date: str) -> None:
+        if not self._ifind_event_lock.acquire(blocking=False):
+            return
+        try:
+            if self.database.get_data_snapshot("ifind_event_enrichment_v1", trade_date):
+                return
+            ifind = getattr(self, "ifind", None)
+            if not ifind or not ifind.configured:
+                return
+            current = datetime.strptime(trade_date, "%Y%m%d")
+            display_date = f"{current.year}年{current.month}月{current.day}日"
+            requests = {
+                "limits": (
+                    f"{display_date}涨停股票，股票代码、股票简称、涨停原因、"
+                    "首次涨停时间、最终涨停时间、开板次数"
+                ),
+                "broken": (
+                    f"{display_date}曾涨停但收盘未涨停的股票，股票代码、股票简称、"
+                    "涨停原因、首次涨停时间、开板次数"
+                ),
+                "down_limits": (
+                    f"{display_date}跌停股票，股票代码、股票简称、跌停原因"
+                ),
+            }
+            result: dict[str, Any] = {
+                "trade_date": trade_date,
+                "generated_at": datetime.now().astimezone().isoformat(timespec="seconds"),
+                "limits": {}, "broken": {}, "down_limits": {}, "partial": False,
+            }
+            for kind, query in requests.items():
+                try:
+                    rows = ifind.wencai(query, "stock", cache_ttl=900)
+                except IfindError:
+                    result["partial"] = True
+                    continue
+                for raw in rows:
+                    code = self._ifind_row_code(raw)
+                    if not code:
+                        continue
+                    reason_tokens = (
+                        ("跌停原因", "风险线索", "原因")
+                        if kind == "down_limits"
+                        else ("涨停原因类别", "涨停原因", "触板逻辑", "原因")
+                    )
+                    reason = str(self._ifind_field(raw, reason_tokens) or "").strip()
+                    first_time = self._normalize_ifind_event_time(
+                        self._ifind_field(raw, ("首次涨停时间", "首次触板时间", "首次封板时间"))
+                    )
+                    last_time = self._normalize_ifind_event_time(
+                        self._ifind_field(raw, ("最终涨停时间", "最后涨停时间", "最后封板时间"))
+                    )
+                    open_times = self._ifind_field(raw, ("开板次数", "打开涨停次数"))
+                    try:
+                        open_count = max(0, int(float(open_times))) if open_times not in (None, "") else None
+                    except (TypeError, ValueError):
+                        open_count = None
+                    result[kind][code] = {
+                        "reason": reason,
+                        "first_time": first_time,
+                        "last_time": last_time,
+                        "open_times": open_count,
+                    }
+            if any(result[kind] for kind in ("limits", "broken", "down_limits")):
+                self.database.save_data_snapshot(
+                    "ifind_event_enrichment_v1", trade_date, "ifind", result
+                )
+        finally:
+            self._ifind_event_lock.release()
+
+    @staticmethod
+    def _ifind_field(row: dict[str, Any], tokens: tuple[str, ...]) -> Any:
+        for key, value in row.items():
+            label = str(key or "")
+            if any(token.casefold() == label.casefold() for token in tokens):
+                return value
+        for key, value in row.items():
+            label = str(key or "")
+            if any(token in label for token in tokens):
+                return value
+        return None
+
+    @classmethod
+    def _ifind_row_code(cls, row: dict[str, Any]) -> str:
+        value = cls._ifind_field(row, ("股票代码", "证券代码", "代码", "thscode"))
+        match = re.search(r"(?<!\d)(\d{6})(?!\d)", str(value or ""))
+        if match:
+            return match.group(1)
+        for value in row.values():
+            match = re.search(r"(?<!\d)(\d{6})\.(?:SH|SZ|BJ)(?![A-Z])", str(value or ""), re.I)
+            if match:
+                return match.group(1)
+        return ""
+
+    @staticmethod
+    def _normalize_ifind_event_time(value: Any) -> str:
+        text = str(value or "").strip()
+        match = re.search(r"(?:^|\s)(\d{1,2}:\d{2}(?::\d{2})?)(?:$|\s)", text)
+        if not match:
+            match = re.search(r"(?<!\d)(\d{6})(?!\d)", text)
+            if match:
+                compact = match.group(1)
+                return f"{compact[:2]}:{compact[2:4]}:{compact[4:]}"
+            return ""
+        parts = match.group(1).split(":")
+        return ":".join(part.zfill(2) for part in parts)
+
+    @staticmethod
+    def _merge_ifind_event_enrichment(
+        dashboard: dict[str, Any], enrichment: dict[str, Any]
+    ) -> None:
+        for kind in ("limits", "broken", "down_limits"):
+            records = enrichment.get(kind) or {}
+            for row in dashboard.get(kind) or []:
+                event = records.get(str(row.get("code") or "")) or {}
+                reason = str(event.get("reason") or "").strip()
+                if reason:
+                    row["reason"] = reason
+                    row["reason_source"] = "market_event"
+                if event.get("first_time"):
+                    row["first_time"] = event["first_time"]
+                if event.get("last_time"):
+                    row["last_time"] = event["last_time"]
+                if event.get("open_times") is not None:
+                    row["open_times"] = event["open_times"]

app/backend/features/popularity/__init__.py

@@ -0,0 +1,4 @@
+from .repository import PopularityRepositoryMixin
+from .service import PopularityServiceMixin
+
+__all__ = ["PopularityRepositoryMixin", "PopularityServiceMixin"]

app/backend/features/popularity/repository.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+class PopularityRepositoryMixin:
+    def upsert_popularity_factors(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("trade_date") or ""),
+                str(row.get("ts_code") or ""),
+                int(row["ths_rank"]) if row.get("ths_rank") not in (None, "") else None,
+                int(row["dc_rank"]) if row.get("dc_rank") not in (None, "") else None,
+                float(row.get("combined_score") or 0),
+                int(row["rank_change"]) if row.get("rank_change") not in (None, "") else None,
+                int(bool(row.get("dual_source"))),
+            )
+            for row in rows
+            if row.get("trade_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO popularity_factors
+                    (trade_date, ts_code, ths_rank, dc_rank, combined_score,
+                     rank_change, dual_source)
+                VALUES (?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    ths_rank=excluded.ths_rank,
+                    dc_rank=excluded.dc_rank,
+                    combined_score=excluded.combined_score,
+                    rank_change=excluded.rank_change,
+                    dual_source=excluded.dual_source
+                """,
+                values,
+            )
+        return len(values)

app/backend/features/popularity/routes.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+from backend.data.providers.tushare_client import TushareError
+
+
+class PopularityRoutesMixin:
+    def _handle_popularity_get(self, parsed) -> bool:
+        if parsed.path == "/api/popularity":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.popularity(
+                        query.get("trade_date", [date.today().isoformat()])[0],
+                        query.get("force", ["0"])[0] == "1",
+                    )
+                )
+            except (ValueError, TushareError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False

app/backend/features/popularity/service.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.bootstrap.config import normalize_date
+from backend.features.market.insights import MarketInsightsService
+
+
+class PopularityServiceMixin:
+    def popularity(self, trade_date: str, force: bool = False) -> dict[str, Any]:
+        return self._market_insights().popularity(normalize_date(trade_date), force)

app/backend/features/review/__init__.py

@@ -1,3 +1,23 @@
-from .trade_journal import EMOTIONS, TRADE_ACTIONS, TradeJournalService
+from .agent import ReviewAssistantError, stream_review_assistant
+from .http import ReviewHttpMixin
+from .repository import ReviewRepositoryMixin
+from .service import ReviewServiceMixin
 
-__all__ = ["EMOTIONS", "TRADE_ACTIONS", "TradeJournalService"]
+__all__ = [
+    "EMOTIONS",
+    "ReviewAssistantError",
+    "ReviewHttpMixin",
+    "ReviewRepositoryMixin",
+    "ReviewServiceMixin",
+    "TRADE_ACTIONS",
+    "TradeJournalService",
+    "stream_review_assistant",
+]
+
+
+def __getattr__(name: str):
+    if name in {"EMOTIONS", "TRADE_ACTIONS", "TradeJournalService"}:
+        from . import trade_journal
+
+        return getattr(trade_journal, name)
+    raise AttributeError(name)

app/backend/features/review/agent.py

@@ -1,12 +1,10 @@
 from __future__ import annotations
 
 import json
-import urllib.error
-import urllib.request
 from collections.abc import Iterator
 from typing import Any
 
-from llm_stream import OpenAIStreamAccumulator
+from backend.llm import transport as llm_transport
 
 
 class ReviewAssistantError(RuntimeError):
@@ -27,48 +25,20 @@ def stream_review_assistant(
     messages = [{"role": "system", "content": _system_prompt(context)}]
     messages.extend(history[-12:])
     messages.append({"role": "user", "content": question})
-    request = urllib.request.Request(
-        f"{base_url.rstrip('/')}/chat/completions",
-        data=json.dumps(
-            {"model": model, "messages": messages, "stream": True}, ensure_ascii=False
-        ).encode("utf-8"),
-        headers={
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {api_key}",
-            "User-Agent": "XiaobaiReviewWeb/1.0",
-            "Accept": "text/event-stream",
-        },
-        method="POST",
-    )
     try:
-        with urllib.request.urlopen(request, timeout=timeout) as response:
-            yielded = False
-            accumulator = OpenAIStreamAccumulator()
-            for raw_line in response:
-                line = raw_line.decode("utf-8", errors="replace").strip()
-                if not line or line.startswith(":"):
-                    continue
-                if line.startswith("data:"):
-                    line = line[5:].strip()
-                if line == "[DONE]":
-                    break
-                try:
-                    payload = json.loads(line)
-                except json.JSONDecodeError:
-                    continue
-                choices = payload.get("choices") or []
-                if not choices:
-                    continue
-                choice = choices[0] or {}
-                content = accumulator.feed(choice)
-                if content:
-                    yielded = True
-                    yield str(content)
-            if not yielded:
-                raise ReviewAssistantError("智能解读未返回有效内容。")
-    except urllib.error.HTTPError as exc:
+        yield from llm_transport.stream_chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=messages,
+            timeout=timeout,
+            user_agent="XiaobaiReviewWeb/1.0",
+        )
+    except llm_transport.OpenAIEmptyResponseError as exc:
+        raise ReviewAssistantError("智能解读未返回有效内容。") from exc
+    except llm_transport.OpenAIHTTPError as exc:
         raise ReviewAssistantError(f"智能解读服务暂不可用（{exc.code}）。") from exc
-    except (urllib.error.URLError, TimeoutError, OSError) as exc:
+    except llm_transport.OpenAITransportError as exc:
         raise ReviewAssistantError("智能解读连接中断，请稍后重试。") from exc
 
 

app/backend/features/review/http.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+from datetime import date
+from http import HTTPStatus
+
+from backend.bootstrap.config import normalize_date, validate_stock_code, validate_text
+from backend.features.review.agent import ReviewAssistantError
+
+
+class ReviewHttpMixin:
+    def save_trade_entry(self) -> None:
+        try:
+            body = self.read_json_body()
+            self.send_json(
+                {"ok": True, **self.application_service.save_trade_entry(body)},
+                HTTPStatus.CREATED,
+            )
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+
+    def stream_assistant_chat(self) -> None:
+        try:
+            body = self.read_json_body()
+            stream = self.application_service.assistant_stream(body)
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return
+        events = ({"type": "delta", "content": chunk} for chunk in stream)
+        self.send_ndjson_stream(events, (ValueError, ReviewAssistantError))
+
+    def save_watchlist(self) -> None:
+        try:
+            body = self.read_json_body()
+            code = validate_stock_code(str(body.get("code", "")))
+            name = validate_text(body.get("name"), "股票名称", 30, required=True)
+            sector = validate_text(body.get("sector"), "所属板块", 50)
+            color = str(body.get("color") or "red")
+            if color not in {"red", "blue", "green", "amber"}:
+                raise ValueError("标记颜色不支持。")
+            remark = validate_text(body.get("remark"), "跟踪备注", 240)
+            service = self.application_service
+            service.database.save_watchlist(
+                service.current_user_id, code, name, sector, color, remark
+            )
+            self.send_json(
+                {
+                    "ok": True,
+                    "items": service.database.list_watchlist(service.current_user_id),
+                }
+            )
+        except (ValueError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+
+    def save_note(self) -> None:
+        try:
+            body = self.read_json_body()
+            code = str(body.get("code") or "").strip()
+            if code:
+                code = validate_stock_code(code)
+            stock_name = validate_text(body.get("stock_name"), "股票名称", 30)
+            trade_date = normalize_date(str(body.get("trade_date") or date.today().isoformat()))
+            summary = validate_text(body.get("summary"), "盘面摘要", 500)
+            content = validate_text(body.get("content"), "复盘内容", 5000)
+            plan = validate_text(body.get("plan"), "明日计划", 2000)
+            if not summary and not content and not plan:
+                raise ValueError("每日复盘内容不能全部为空。")
+            raw_id = body.get("id")
+            note_id = int(raw_id) if raw_id else None
+            service = self.application_service
+            saved_id = service.database.save_note(
+                service.current_user_id,
+                code,
+                stock_name,
+                trade_date,
+                content,
+                plan,
+                note_id,
+                summary=summary,
+            )
+            self.send_json({"ok": True, "id": saved_id})
+        except (ValueError, TypeError, json.JSONDecodeError) as exc:
+            self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)

app/backend/features/review/repository.py

@@ -0,0 +1,281 @@
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from typing import Any
+
+
+class ReviewRepositoryMixin:
+    def list_watchlist(self, user_id: int) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT code, name, sector, color, remark, created_at, updated_at
+                FROM watchlist WHERE user_id = ? ORDER BY updated_at DESC, code
+                """,
+                (int(user_id),),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def save_watchlist(
+        self, user_id: int, code: str, name: str, sector: str, color: str,
+        remark: str | None = None,
+    ) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            existing = connection.execute(
+                "SELECT remark FROM watchlist WHERE user_id = ? AND code = ?",
+                (int(user_id), code),
+            ).fetchone()
+            saved_remark = (
+                str(existing["remark"] or "") if remark is None and existing else str(remark or "")
+            )
+            connection.execute(
+                """
+                INSERT INTO watchlist
+                    (user_id, code, name, sector, color, remark, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(user_id, code) DO UPDATE SET
+                    name = excluded.name,
+                    sector = excluded.sector,
+                    color = excluded.color,
+                    remark = excluded.remark,
+                    updated_at = excluded.updated_at
+                """,
+                (int(user_id), code, name, sector, color, saved_remark, now, now),
+            )
+
+    def watchlist_price_history(
+        self, codes: list[str], end_date: str, limit_per_code: int = 6
+    ) -> dict[str, list[dict[str, Any]]]:
+        result: dict[str, list[dict[str, Any]]] = {}
+        if not codes:
+            return result
+        with self.connect() as connection:
+            for code in codes:
+                rows = connection.execute(
+                    """
+                    SELECT trade_date, ts_code, close, pct_chg
+                    FROM daily_bars
+                    WHERE substr(ts_code, 1, 6) = ? AND trade_date <= ?
+                    ORDER BY trade_date DESC LIMIT ?
+                    """,
+                    (str(code), end_date, int(limit_per_code)),
+                ).fetchall()
+                result[str(code)] = [dict(row) for row in reversed(rows)]
+        return result
+
+    def delete_watchlist(self, user_id: int, code: str) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM watchlist WHERE user_id = ? AND code = ?",
+                (int(user_id), code),
+            )
+            return cursor.rowcount > 0
+
+    def list_notes(
+        self,
+        user_id: int,
+        code: str = "",
+        trade_date: str = "",
+        scope: str = "all",
+    ) -> list[dict[str, Any]]:
+        clauses: list[str] = ["user_id = ?"]
+        parameters: list[Any] = [int(user_id)]
+        if scope == "daily":
+            clauses.append("code = ''")
+        elif scope == "stock":
+            clauses.append("code <> ''")
+        if code:
+            clauses.append("code = ?")
+            parameters.append(code)
+        if trade_date:
+            clauses.append("trade_date = ?")
+            parameters.append(trade_date)
+        where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT id, code, stock_name, trade_date, summary, content, plan, created_at, updated_at
+                FROM review_notes {where}
+                ORDER BY trade_date DESC, updated_at DESC, id DESC LIMIT 200
+                """,
+                parameters,
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def save_note(
+        self,
+        user_id: int,
+        code: str,
+        stock_name: str,
+        trade_date: str,
+        content: str,
+        plan: str,
+        note_id: int | None = None,
+        summary: str = "",
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            if note_id:
+                cursor = connection.execute(
+                    """
+                    UPDATE review_notes
+                    SET code = ?, stock_name = ?, trade_date = ?, summary = ?, content = ?, plan = ?, updated_at = ?
+                    WHERE id = ? AND user_id = ?
+                    """,
+                    (code, stock_name, trade_date, summary, content, plan, now, note_id, int(user_id)),
+                )
+                if cursor.rowcount == 0:
+                    raise ValueError("复盘笔记不存在。")
+                return note_id
+            cursor = connection.execute(
+                """
+                INSERT INTO review_notes
+                    (user_id, code, stock_name, trade_date, summary, content, plan, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (int(user_id), code, stock_name, trade_date, summary, content, plan, now, now),
+            )
+            return int(cursor.lastrowid)
+
+    def delete_note(self, user_id: int, note_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM review_notes WHERE id = ? AND user_id = ?",
+                (note_id, int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def save_trade_entry(
+        self,
+        user_id: int,
+        trade_date: str,
+        code: str,
+        name: str,
+        action: str,
+        price: float,
+        quantity: int,
+        position_pct: float,
+        pnl_amount: float | None,
+        pnl_pct: float | None,
+        thesis: str,
+        execution: str,
+        emotion: str,
+        tags: list[str],
+        trade_id: int | None = None,
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        tags_json = json.dumps(tags, ensure_ascii=False, separators=(",", ":"))
+        with self.connect() as connection:
+            if trade_id:
+                cursor = connection.execute(
+                    """
+                    UPDATE trade_entries SET
+                        trade_date=?, code=?, name=?, action=?, price=?, quantity=?,
+                        position_pct=?, pnl_amount=?, pnl_pct=?, thesis=?, execution=?,
+                        emotion=?, tags=?, updated_at=?
+                    WHERE id=? AND user_id=?
+                    """,
+                    (
+                        trade_date, code, name, action, price, quantity, position_pct,
+                        pnl_amount, pnl_pct, thesis, execution, emotion, tags_json, now,
+                        int(trade_id), int(user_id),
+                    ),
+                )
+                if cursor.rowcount == 0:
+                    raise ValueError("交易记录不存在或无权修改。")
+                return int(trade_id)
+            cursor = connection.execute(
+                """
+                INSERT INTO trade_entries
+                    (user_id, trade_date, code, name, action, price, quantity,
+                     position_pct, pnl_amount, pnl_pct, thesis, execution, emotion,
+                     tags, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (
+                    int(user_id), trade_date, code, name, action, price, quantity,
+                    position_pct, pnl_amount, pnl_pct, thesis, execution, emotion,
+                    tags_json, now, now,
+                ),
+            )
+            return int(cursor.lastrowid)
+
+    def list_trade_entries(
+        self, user_id: int, start_date: str = "", end_date: str = "", code: str = "",
+        limit: int = 300,
+    ) -> list[dict[str, Any]]:
+        clauses = ["user_id = ?"]
+        parameters: list[Any] = [int(user_id)]
+        if start_date:
+            clauses.append("trade_date >= ?")
+            parameters.append(start_date)
+        if end_date:
+            clauses.append("trade_date <= ?")
+            parameters.append(end_date)
+        if code:
+            clauses.append("code = ?")
+            parameters.append(code)
+        parameters.append(max(1, min(1000, int(limit))))
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT * FROM trade_entries WHERE {' AND '.join(clauses)}
+                ORDER BY trade_date DESC, id DESC LIMIT ?
+                """,
+                parameters,
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def delete_trade_entry(self, user_id: int, trade_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM trade_entries WHERE id = ? AND user_id = ?",
+                (int(trade_id), int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def save_assistant_exchange(
+        self, user_id: int, question: str, answer: str, context_date: str
+    ) -> None:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO assistant_messages
+                    (user_id, role, content, context_date, created_at)
+                VALUES (?, ?, ?, ?, ?)
+                """,
+                [
+                    (int(user_id), "user", question, context_date, now),
+                    (int(user_id), "assistant", answer, context_date, now),
+                ],
+            )
+            connection.execute(
+                """
+                DELETE FROM assistant_messages WHERE user_id = ? AND id NOT IN (
+                    SELECT id FROM assistant_messages
+                    WHERE user_id = ? ORDER BY id DESC LIMIT 200
+                )
+                """,
+                (int(user_id), int(user_id)),
+            )
+
+    def list_assistant_messages(self, user_id: int, limit: int = 100) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT role, content, context_date, created_at FROM assistant_messages
+                WHERE user_id = ? ORDER BY id DESC LIMIT ?
+                """,
+                (int(user_id), max(1, min(200, int(limit)))),
+            ).fetchall()
+        return [dict(row) for row in reversed(rows)]
+
+    def delete_assistant_messages(self, user_id: int) -> int:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM assistant_messages WHERE user_id = ?", (int(user_id),)
+            )
+            return int(cursor.rowcount)

app/backend/features/review/routes.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+
+
+class ReviewRoutesMixin:
+    def _handle_review_get(self, parsed) -> bool:
+        if parsed.path == "/api/trades":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.trade_entries(
+                        query.get("start_date", [""])[0],
+                        query.get("end_date", [""])[0],
+                        query.get("code", [""])[0],
+                    )
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/assistant/messages":
+            self.send_json({"items": self.application_service.assistant_messages()})
+            return True
+        if parsed.path == "/api/watchlist":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.review_watchlist(
+                        query.get("trade_date", [date.today().isoformat()])[0]
+                    )
+                )
+            except ValueError as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/notes":
+            query = parse_qs(parsed.query)
+            code = query.get("code", [""])[0]
+            trade_date = query.get("trade_date", [""])[0].replace("-", "")
+            scope = query.get("scope", ["all"])[0]
+            if scope not in {"all", "daily", "stock"}:
+                self.send_json({"error": "复盘记录范围不支持。"}, HTTPStatus.BAD_REQUEST)
+                return True
+            self.send_json(
+                {
+                    "items": self.application_service.database.list_notes(
+                        self.application_service.current_user_id, code, trade_date, scope
+                    )
+                }
+            )
+            return True
+        return False
+
+    def _handle_review_delete(self, parsed) -> bool:
+        if parsed.path == "/api/assistant/messages":
+            deleted = self.application_service.clear_assistant_messages()
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        watchlist_match = re.fullmatch(r"/api/watchlist/(\d{6})", parsed.path)
+        if watchlist_match:
+            deleted = self.application_service.database.delete_watchlist(
+                self.application_service.current_user_id, watchlist_match.group(1)
+            )
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        note_match = re.fullmatch(r"/api/notes/(\d+)", parsed.path)
+        if note_match:
+            deleted = self.application_service.database.delete_note(
+                self.application_service.current_user_id, int(note_match.group(1))
+            )
+            self.send_json({"ok": True, "deleted": deleted})
+            return True
+        trade_match = re.fullmatch(r"/api/trades/(\d+)", parsed.path)
+        if trade_match:
+            self.send_json(
+                {"ok": True, **self.application_service.delete_trade_entry(int(trade_match.group(1)))}
+            )
+            return True
+        return False

app/backend/features/review/service.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+from datetime import date, datetime, timedelta
+from typing import Any
+
+from backend.bootstrap.config import normalize_date, tushare_code, validate_text
+from backend.data.providers.tushare_client import TushareError
+from backend.features.review.agent import ReviewAssistantError, stream_review_assistant
+
+
+class ReviewServiceMixin:
+    def trade_entries(
+        self, start_date: str = "", end_date: str = "", code: str = ""
+    ) -> dict[str, Any]:
+        return self.trade_journal.list_entries(
+            self.current_user_id, start_date, end_date, code
+        )
+
+    def review_watchlist(self, trade_date: str) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        items = self.database.list_watchlist(self.current_user_id)
+        if not items:
+            return {"items": [], "trade_date": normalized_date}
+
+        resolved_date = normalized_date
+        if self.configured:
+            try:
+                client = self._tushare_client()
+                resolved_date, _ = client.resolve_trade_context(normalized_date)
+                history = self.database.watchlist_price_history(
+                    [str(item["code"]) for item in items], resolved_date
+                )
+                missing_codes = [
+                    str(item["code"]) for item in items
+                    if len(history.get(str(item["code"])) or []) < 6
+                ]
+                start_date = (
+                    datetime.strptime(resolved_date, "%Y%m%d") - timedelta(days=24)
+                ).strftime("%Y%m%d")
+                for code in missing_codes:
+                    rows = client.query(
+                        "daily",
+                        {
+                            "ts_code": tushare_code(code),
+                            "start_date": start_date,
+                            "end_date": resolved_date,
+                        },
+                        "ts_code,trade_date,open,high,low,close,pct_chg,vol,amount",
+                    )
+                    if rows:
+                        self.database.upsert_daily_bars(rows)
+                if missing_codes:
+                    history = self.database.watchlist_price_history(
+                        [str(item["code"]) for item in items], resolved_date
+                    )
+            except (TushareError, ValueError):
+                history = self.database.watchlist_price_history(
+                    [str(item["code"]) for item in items], resolved_date
+                )
+        else:
+            history = self.database.watchlist_price_history(
+                [str(item["code"]) for item in items], resolved_date
+            )
+
+        auction_scores: dict[str, Any] = {}
+        try:
+            auction = self.auction_center(normalized_date, False)
+            auction_scores = {
+                str(row.get("code") or ""): row.get("attention_score")
+                for row in (auction.get("watchlist_rows") or [])
+                if row.get("available", True)
+            }
+        except (TushareError, ValueError):
+            pass
+
+        enriched = []
+        for item in items:
+            code = str(item.get("code") or "")
+            bars = history.get(code) or []
+            latest = bars[-1] if bars else {}
+            close = float(latest.get("close") or 0)
+            base_close = float(bars[-6].get("close") or 0) if len(bars) >= 6 else 0
+            enriched.append(
+                {
+                    **item,
+                    "change": (
+                        round(float(latest.get("pct_chg") or 0), 2) if latest else None
+                    ),
+                    "return_5d": (
+                        round((close / base_close - 1) * 100, 2)
+                        if close > 0 and base_close > 0 else None
+                    ),
+                    "attention_score": auction_scores.get(code),
+                    "market_date": str(latest.get("trade_date") or ""),
+                }
+            )
+        return {"items": enriched, "trade_date": resolved_date}
+
+    def save_trade_entry(self, payload: dict[str, Any]) -> dict[str, Any]:
+        trade_id = self.trade_journal.save(self.current_user_id, payload)
+        return {"id": trade_id, **self.trade_entries()}
+
+    def delete_trade_entry(self, trade_id: int) -> dict[str, Any]:
+        deleted = self.trade_journal.delete(self.current_user_id, trade_id)
+        return {"deleted": deleted, **self.trade_entries()}
+
+    def assistant_messages(self) -> list[dict[str, Any]]:
+        return self.database.list_assistant_messages(self.current_user_id)
+
+    def clear_assistant_messages(self) -> int:
+        return self.database.delete_assistant_messages(self.current_user_id)
+
+    def assistant_stream(self, payload: dict[str, Any]):
+        question = validate_text(payload.get("question"), "问题", 2000, required=True)
+        trade_date = normalize_date(
+            str(payload.get("trade_date") or date.today().isoformat())
+        )
+        context = self._assistant_context(trade_date)
+        history = [
+            {"role": item["role"], "content": str(item["content"])[:4000]}
+            for item in self.assistant_messages()[-12:]
+            if item.get("role") in {"user", "assistant"}
+        ]
+        def generate():
+            answer_parts: list[str] = []
+            events = self.llm_gateway.stream(
+                "assistant",
+                "review-assistant-v1",
+                lambda profile: stream_review_assistant(
+                    context,
+                    question,
+                    history,
+                    profile.api_key,
+                    profile.base_url,
+                    profile.model,
+                ),
+                (ReviewAssistantError,),
+            )
+            for event in events:
+                if event.kind == "delta":
+                    chunk = str(event.value or "")
+                    answer_parts.append(chunk)
+                    yield chunk
+                elif event.kind == "complete":
+                    self.database.save_assistant_exchange(
+                        self.current_user_id,
+                        question,
+                        "".join(answer_parts).strip(),
+                        trade_date,
+                    )
+
+        return generate()
+
+    def _assistant_context(self, trade_date: str) -> dict[str, Any]:
+        dashboard = self.get_dashboard(trade_date)
+        actual_date = normalize_date(
+            str((dashboard.get("meta") or {}).get("trade_date") or trade_date)
+        )
+        sentiment = self.sentiment_history(actual_date, 10)
+        tracking = self.strategy_tracking.list_tracking(self.current_user_id, 5)
+        alerts = self.alert_service.list_alerts(
+            self.current_user_id, "all", date.today().isoformat()
+        )
+        trades = self.trade_journal.list_entries(
+            self.current_user_id, end_date=actual_date
+        )
+        return {
+            "data_date": actual_date,
+            "market": {
+                "overview": dashboard.get("overview") or {},
+                "top_sectors": (dashboard.get("sectors") or [])[:8],
+                "limit_performance": dashboard.get("limit_performance") or {},
+                "sentiment_history": (sentiment.get("rows") or [])[-10:],
+            },
+            "personal": {
+                "watchlist": self.database.list_watchlist(self.current_user_id)[:30],
+                "review_notes": self.database.list_notes(
+                    self.current_user_id, scope="daily"
+                )[:10],
+                "strategy_tracking": {
+                    "summary": tracking.get("summary") or {},
+                    "batches": (tracking.get("batches") or [])[:5],
+                },
+                "alerts": (alerts.get("items") or [])[:20],
+                "trade_summary": trades.get("summary") or {},
+                "trade_entries": (trades.get("items") or [])[:30],
+            },
+        }

app/backend/features/rotation/__init__.py

@@ -0,0 +1,5 @@
+"""Sector rotation history and constituent detail feature."""
+
+from .service import RotationServiceMixin
+
+__all__ = ["RotationServiceMixin"]

app/backend/features/rotation/routes.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from datetime import date
+from http import HTTPStatus
+from urllib.parse import parse_qs
+
+
+class RotationRoutesMixin:
+    def _handle_rotation_get(self, parsed) -> bool:
+        if parsed.path == "/api/rotation/history":
+            query = parse_qs(parsed.query)
+            trade_date = query.get("trade_date", [date.today().isoformat()])[0]
+            try:
+                self.send_json(self.application_service.rotation_history(trade_date, 9))
+            except (TypeError, ValueError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        if parsed.path == "/api/rotation/members":
+            query = parse_qs(parsed.query)
+            try:
+                self.send_json(
+                    self.application_service.rotation_sector_members(
+                        query.get("trade_date", [date.today().isoformat()])[0],
+                        query.get("sector", [""])[0],
+                    )
+                )
+            except (TypeError, ValueError) as exc:
+                self.send_json({"error": str(exc)}, HTTPStatus.BAD_REQUEST)
+            return True
+        return False

app/backend/features/rotation/service.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.bootstrap.config import normalize_date, validate_text
+from backend.data.providers.tushare_client import TushareError
+from backend.features.sentiment.engine import (
+    build_sentiment_history,
+    latest_contiguous_history,
+)
+
+
+class RotationServiceMixin:
+    def rotation_history(self, trade_date: str, limit: int = 9) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        # 板块轮动固定展示最近 9 个交易日，按由近到远排列。
+        limit = 9
+        snapshots = self.database.list_snapshot_payloads(normalized_date, 240)
+        by_trade_date: dict[str, dict[str, Any]] = {}
+        for snapshot in snapshots:
+            meta = snapshot.get("meta") or {}
+            actual_date = str(meta.get("trade_date") or snapshot.get("_snapshot_date") or "")
+            compact_date = actual_date.replace("-", "")
+            if len(compact_date) == 8:
+                by_trade_date[compact_date] = snapshot
+
+        sentiment_dates = {
+            str(row.get("trade_date") or "").replace("-", "")
+            for row in latest_contiguous_history(build_sentiment_history(snapshots))
+        }
+        ordered_dates = sorted(
+            date_key for date_key in by_trade_date
+            if not sentiment_dates or date_key in sentiment_dates
+        )[-limit:][::-1]
+        rows = []
+        for date_key in ordered_dates:
+            snapshot = by_trade_date[date_key]
+            sector_context = {
+                str(item.get("name") or ""): item
+                for item in snapshot.get("sectors") or []
+            }
+            sectors = []
+            for item in (snapshot.get("sector_rotation") or [])[:12]:
+                name = str(item.get("name") or "").strip()
+                context = sector_context.get(name, {})
+                sectors.append(
+                    {
+                        "name": name,
+                        "rank": int(item.get("rank") or len(sectors) + 1),
+                        "trend": item.get("trend") or "持平",
+                        "count": int(item.get("count") or 0),
+                        "strength": float(item.get("strength") or context.get("strength") or 0),
+                        "change": float(context.get("change") or 0),
+                        "leader": item.get("leader") or context.get("leader") or "--",
+                    }
+                )
+            rows.append(
+                {
+                    "trade_date": f"{date_key[:4]}-{date_key[4:6]}-{date_key[6:]}",
+                    "sectors": sectors,
+                }
+            )
+        return {
+            "trade_date": rows[0]["trade_date"] if rows else normalized_date,
+            "available_days": len(ordered_dates),
+            "requested_days": limit,
+            "rows": rows,
+        }
+
+    def rotation_sector_members(self, trade_date: str, sector_name: str) -> dict[str, Any]:
+        normalized_date = normalize_date(trade_date)
+        sector_name = validate_text(sector_name, "板块名称", 60, required=True)
+        dashboard = self.get_dashboard(normalized_date)
+        actual_date = normalize_date(
+            str((dashboard.get("meta") or {}).get("trade_date") or normalized_date)
+        )
+        cache_key = f"{actual_date}:{sector_name}"
+        cached = self.database.get_data_snapshot("rotation_sector_members_v1", cache_key)
+        if cached:
+            cached["meta"] = {**(cached.get("meta") or {}), "cached": True}
+            return cached
+        if not self.configured:
+            raise ValueError("板块成分数据暂不可用。")
+
+        representative = next(
+            (
+                item for item in dashboard.get("limits") or []
+                if str(item.get("sector") or "").strip() == sector_name
+            ),
+            None,
+        )
+        if not representative:
+            raise ValueError("未找到该板块的代表股票，暂时无法核验成分股。")
+        raw_code = str(representative.get("ts_code") or representative.get("code") or "")
+        if "." in raw_code:
+            ts_code = raw_code
+        elif raw_code.startswith(("4", "8", "92")):
+            ts_code = f"{raw_code}.BJ"
+        elif raw_code.startswith(("6", "68", "90")):
+            ts_code = f"{raw_code}.SH"
+        else:
+            ts_code = f"{raw_code}.SZ"
+        client = self._tushare_client()
+        try:
+            industry = client.sw_stock_industry(ts_code, actual_date)
+            sector_code = str(industry.get("l2_code") or "")
+            members = client.sw_sector_members(sector_code, actual_date)
+        except TushareError as exc:
+            raise ValueError(f"该板块成分股暂不可用：{exc}") from exc
+
+        daily_rows = self.database.daily_bars_for_date(actual_date)
+        if len(daily_rows) < 1000:
+            try:
+                daily_rows = client.query(
+                    "daily",
+                    {"trade_date": actual_date},
+                    "ts_code,trade_date,open,high,low,close,pct_chg,vol,amount",
+                )
+                if daily_rows:
+                    self.database.upsert_daily_bars(daily_rows)
+            except TushareError:
+                daily_rows = self.database.daily_bars_for_date(actual_date)
+        daily_map = {str(item.get("ts_code") or ""): item for item in daily_rows}
+        rows = []
+        for member in members:
+            member_code = str(member.get("ts_code") or "")
+            quote = daily_map.get(member_code) or {}
+            rows.append(
+                {
+                    "code": member_code.split(".")[0],
+                    "ts_code": member_code,
+                    "name": str(member.get("name") or "--"),
+                    "change": quote.get("pct_chg"),
+                    "open": quote.get("open"),
+                    "close": quote.get("close"),
+                    "amount_billion": (
+                        round(float(quote.get("amount") or 0) / 100000, 2)
+                        if quote else None
+                    ),
+                    "quoted": bool(quote),
+                }
+            )
+        rows.sort(
+            key=lambda item: (
+                bool(item.get("quoted")),
+                float(item.get("change") or -999),
+                float(item.get("amount_billion") or 0),
+            ),
+            reverse=True,
+        )
+        result = {
+            "meta": {
+                "trade_date": self._display_compact_date(actual_date),
+                "sector_name": str(industry.get("l2_name") or sector_name),
+                "sector_code": sector_code,
+                "member_count": len(rows),
+                "quoted_count": sum(bool(item.get("quoted")) for item in rows),
+                "cached": False,
+            },
+            "rows": rows,
+        }
+        self.database.save_data_snapshot(
+            "rotation_sector_members_v1", cache_key, "tushare", result
+        )
+        return result

app/backend/features/screener/__init__.py

@@ -1,3 +1 @@
-from .tracking import StrategyTrackingService
-
-__all__ = ["StrategyTrackingService"]
+"""Stock screening, custom selection, and strategy tracking feature."""

app/backend/features/screener/backtest.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+import statistics
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.features.screener.factors import FactorBuilder
+from backend.features.screener.formula import FormulaEvaluator
+from database import ReviewDatabase
+
+
+class BacktestRunner:
+    def __init__(
+        self,
+        database: ReviewDatabase,
+        factor_builder: FactorBuilder,
+        formula_evaluator: FormulaEvaluator,
+    ) -> None:
+        self.database = database
+        self.factor_builder = factor_builder
+        self.formula_evaluator = formula_evaluator
+        self._backtest_factor_cache: dict[tuple[str, int], list[dict[str, Any]]] = {}
+
+    def build_factors(
+        self, trade_date: str, history_days: int
+    ) -> tuple[list[dict[str, Any]], str]:
+        return self.factor_builder.build_factors(
+            trade_date, history_days=history_days
+        )
+
+    def apply_formula(
+        self, rows: list[dict[str, Any]], formula: dict[str, Any], regime: str
+    ) -> list[dict[str, Any]]:
+        return self.formula_evaluator.apply_formula(rows, formula, regime)
+
+    def backtest(self, trade_date: str, formula: dict[str, Any]) -> dict[str, Any]:
+        meta = formula.get("meta") or {}
+        history_days = max(21, min(260, int(meta.get("history_days") or 80)))
+        holding_days = max(1, min(30, int(meta.get("backtest_days") or 3)))
+        take_profit = max(0.5, min(50.0, float(meta.get("take_profit") or 3)))
+        stop_loss = min(-0.5, max(-50.0, float(meta.get("stop_loss") or -3)))
+        dates = self.database.factor_dates(trade_date, history_days + holding_days + 20)
+        eligible_dates = dates[:-holding_days] if len(dates) > holding_days else []
+        frequency = str(meta.get("frequency") or "每日")
+        if "月" in frequency:
+            grouped = {}
+            for value in eligible_dates:
+                grouped[value[:6]] = value
+            evaluation_dates = list(grouped.values())[-8:]
+        elif "双周" in frequency:
+            weekly_dates = []
+            grouped = {}
+            for value in eligible_dates:
+                parsed = datetime.strptime(value, "%Y%m%d")
+                grouped[parsed.strftime("%G-%V")] = value
+            weekly_dates = list(grouped.values())
+            evaluation_dates = weekly_dates[-16::2][-8:]
+        elif "周" in frequency:
+            grouped = {}
+            for value in eligible_dates:
+                parsed = datetime.strptime(value, "%Y%m%d")
+                grouped[parsed.strftime("%G-%V")] = value
+            evaluation_dates = list(grouped.values())[-8:]
+        else:
+            evaluation_dates = eligible_dates[-8:]
+        wins = 0
+        losses = 0
+        samples = 0
+        returns = []
+        drawdowns = []
+        all_data = self.database.load_factor_data(
+            trade_date, history_days + holding_days + 20
+        )
+        bars_by_code: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in all_data["bars"]:
+            bars_by_code[row["ts_code"]].append(row)
+        for bars in bars_by_code.values():
+            bars.sort(key=lambda item: item["trade_date"])
+
+        for current_date in evaluation_dates:
+            try:
+                cache_key = (current_date, history_days)
+                factors = self._backtest_factor_cache.get(cache_key)
+                if factors is None:
+                    factors, _ = self.build_factors(
+                        current_date, history_days=history_days
+                    )
+                    if len(self._backtest_factor_cache) >= 64:
+                        self._backtest_factor_cache.pop(
+                            next(iter(self._backtest_factor_cache))
+                        )
+                    self._backtest_factor_cache[cache_key] = factors
+            except ValueError:
+                continue
+            selected = self.apply_formula(factors, {**formula, "limit": min(10, formula["limit"])}, "backtest")
+            for candidate in selected:
+                bars = bars_by_code.get(candidate["ts_code"], [])
+                index = next((i for i, row in enumerate(bars) if row["trade_date"] == current_date), -1)
+                future = bars[index + 1:index + 1 + holding_days] if index >= 0 else []
+                if len(future) < holding_days:
+                    continue
+                entry = candidate["price"]
+                won = False
+                lost = False
+                for day in future:
+                    low_return = (_number(day["low"]) / entry - 1) * 100
+                    high_return = (_number(day["high"]) / entry - 1) * 100
+                    if low_return <= stop_loss:
+                        lost = True
+                        break
+                    if high_return >= take_profit:
+                        won = True
+                        break
+                if won:
+                    wins += 1
+                elif lost:
+                    losses += 1
+                samples += 1
+                returns.append((_number(future[-1]["close"]) / entry - 1) * 100)
+                drawdowns.append(min((_number(day["low"]) / entry - 1) * 100 for day in future))
+        return {
+            "samples": samples,
+            "wins": wins,
+            "losses": losses,
+            "win_rate": round(wins / samples * 100, 1) if samples else 0,
+            "average_3d_return": round(statistics.fmean(returns), 2) if returns else 0,
+            "average_holding_return": round(statistics.fmean(returns), 2) if returns else 0,
+            "average_drawdown": round(statistics.fmean(drawdowns), 2) if drawdowns else 0,
+            "evaluation_days": len(evaluation_dates),
+            "frequency": frequency,
+            "holding_days": holding_days,
+            "take_profit": take_profit,
+            "stop_loss": stop_loss,
+            "definition": (
+                f"收盘后选股，未来{holding_days}日先触及+{take_profit:g}%且未先触及"
+                f"{stop_loss:g}%计为成功；同日双触发按失败处理。"
+            ),
+            "approximate": True,
+        }

app/backend/features/screener/catalog.py

@@ -0,0 +1,711 @@
+from __future__ import annotations
+
+from backend.features.screener.strategies import ADVANCED_CURATED_STRATEGIES
+from backend.features.screener.signals import attach_strategy_validity
+
+
+REGIMES = {
+    "ice": "冰点",
+    "repair": "修复",
+    "fermentation": "发酵",
+    "climax": "高潮",
+    "divergence": "分化",
+    "retreat": "退潮",
+}
+
+FACTOR_FIELDS = {
+    "close": "收盘价",
+    "pct_chg": "当日涨幅",
+    "return_5d": "5日涨幅",
+    "return_10d": "10日涨幅",
+    "return_20d": "20日涨幅",
+    "return_60d": "60日涨幅",
+    "return_5d_rank": "5日涨幅排名",
+    "momentum_60_5": "中期动量",
+    "momentum_60_5_rank": "中期动量排名",
+    "above_ma20": "站上20日线",
+    "rsi_6": "RSI(6)",
+    "ma60_slope": "60日线斜率",
+    "ma20_slope_5d": "20日线5日斜率",
+    "ma_bull_alignment": "均线多头排列",
+    "drawdown_from_high_250": "距250日高点回撤",
+    "donchian_breakout_pct": "唐奇安突破幅度",
+    "range_20d": "20日振幅",
+    "rs_high_120": "RS线120日新高",
+    "excess_return_60d": "60日超额收益",
+    "weekly_trend_signal": "周线趋势信号",
+    "daily_buy_trigger": "日线买点",
+    "weekly_amount_trend": "周成交趋势",
+    "volume_ratio_5d": "5日量比",
+    "turnover_5d": "5日累计换手",
+    "volatility_10d": "10日波动率",
+    "amount_billion": "成交额",
+    "turnover_rate": "换手率",
+    "circ_mv_billion": "流通市值",
+    "net_flow_million": "主力净流入",
+    "large_flow_million": "大单净流入",
+    "net_flow_5d_million": "5日主力净流入",
+    "flow_to_circ_mv_5d": "5日净流入占流通市值",
+    "sector_strength": "板块强度",
+    "sector_return_5d": "行业5日涨幅",
+    "sector_return_20d": "行业20日涨幅",
+    "sector_momentum_rank": "行业20日动量排名",
+    "sector_stock_momentum_rank": "行业内个股动量排名",
+    "sector_net_flow_5d_million": "行业5日主力净流入",
+    "sector_flow_rank": "行业资金流排名",
+    "sector_prosperity_rank": "行业景气度排名",
+    "sector_trend_rank": "行业趋势排名",
+    "sector_crowding_rank": "行业拥挤度排名",
+    "sector_composite_score": "行业三维综合分",
+    "sector_limit_count": "板块涨停数",
+    "sector_up_count": "板块强势股数",
+    "relative_strength": "相对强度",
+    "limit_streak": "连板高度",
+    "auction_change": "竞价涨幅",
+    "auction_amount_million": "竞价成交额",
+    "auction_turnover_rate": "竞价换手率",
+    "auction_volume_ratio": "竞价量比",
+    "total_mv_billion": "总市值",
+    "pe_ttm": "市盈率TTM",
+    "pb": "市净率",
+    "ps_ttm": "市销率TTM",
+    "dividend_yield_ttm": "股息率TTM",
+    "dividend_years": "近年持续分红",
+    "roe": "净资产收益率",
+    "roa": "总资产收益率",
+    "roic": "投入资本回报率",
+    "gross_margin": "销售毛利率",
+    "netprofit_yoy": "净利润同比",
+    "revenue_yoy": "营业收入同比",
+    "ocf_to_opincome": "经营现金流质量",
+    "earnings_surprise_pct": "业绩超预期幅度",
+    "earnings_days_since_announce": "业绩公告后天数",
+    "earnings_event_quality": "业绩事件质量",
+    "popularity_score": "人气榜热度",
+    "popularity_rank_change": "人气排名跃升",
+    "popularity_dual_source": "双榜共识",
+    "institution_net_buy_million": "机构席位净买入",
+    "institution_seat_count": "机构席位数",
+    "style_size_fit": "大小盘风格匹配",
+    "style_growth_fit": "成长价值风格匹配",
+    "style_fit_score": "当前风格匹配度",
+    "factor_value_score": "价值因子分",
+    "factor_growth_score": "成长因子分",
+    "factor_quality_score": "质量因子分",
+    "factor_momentum_score": "动量因子分",
+    "factor_sentiment_score": "交易情绪因子分",
+    "multi_factor_composite": "动态多因子综合分",
+    "relative_position_60": "60日相对位置",
+    "max_abs_change_15d": "15日最大波动",
+    "close_to_high_15d": "距15日高点",
+    "close_to_high_60d": "距60日高点",
+    "no_limit_30d": "近30日无涨停",
+    "had_limit_80d": "近80日曾涨停",
+    "previous_first_limit": "昨日首板",
+    "previous_limit_signal": "昨日涨停或触板",
+    "previous_limit_streak": "昨日连板高度",
+    "previous_amount_billion": "昨日成交额",
+    "is_limit_up_today": "当日涨停",
+    "is_limit_down_today": "当日跌停",
+    "sector_breadth_ma20": "行业20日线宽度",
+    "no_limit_down_20d": "近20日无跌停",
+    "financial_risk": "财务风险标记",
+    "is_market_height": "当前市场最高板",
+    "new_space_board": "新晋空间板",
+    "max_continuous_board_10d": "近10日最高连板",
+    "dragon_first_yin": "龙头首阴",
+    "yin_day_pct": "首阴跌幅",
+    "vol_vs_previous": "较前日量能",
+    "broken_reversal": "断板反包",
+    "days_since_broken": "断板后天数",
+    "close_above_broken_high": "收复断板高点",
+    "vol_vs_broken_day": "较断板日量能",
+    "recent_limit_up_5d": "近5日涨停次数",
+    "intraday_min_pct": "盘中最大跌幅",
+    "lower_shadow_ratio": "下影线实体比",
+}
+
+FACTOR_GROUPS = {
+    "行情动量": [
+        "close", "pct_chg", "return_5d", "return_10d", "return_20d", "return_60d",
+        "return_5d_rank", "momentum_60_5", "momentum_60_5_rank", "above_ma20",
+        "rsi_6", "ma60_slope", "ma20_slope_5d", "ma_bull_alignment",
+        "drawdown_from_high_250", "donchian_breakout_pct", "range_20d",
+        "rs_high_120", "excess_return_60d", "weekly_trend_signal",
+        "daily_buy_trigger", "weekly_amount_trend", "relative_strength",
+        "relative_position_60", "close_to_high_15d", "close_to_high_60d",
+    ],
+    "量价交易": [
+        "volume_ratio_5d", "turnover_5d", "volatility_10d", "amount_billion", "turnover_rate",
+        "net_flow_million", "large_flow_million", "net_flow_5d_million",
+        "flow_to_circ_mv_5d", "previous_amount_billion",
+        "intraday_min_pct", "lower_shadow_ratio", "vol_vs_previous", "vol_vs_broken_day",
+    ],
+    "板块结构": [
+        "sector_strength", "sector_return_5d", "sector_return_20d", "sector_momentum_rank",
+        "sector_stock_momentum_rank", "sector_net_flow_5d_million", "sector_flow_rank",
+        "sector_prosperity_rank", "sector_trend_rank", "sector_crowding_rank",
+        "sector_composite_score",
+        "sector_limit_count", "sector_up_count", "sector_breadth_ma20",
+        "limit_streak", "previous_limit_streak", "previous_first_limit", "previous_limit_signal",
+        "is_limit_up_today", "is_limit_down_today",
+        "no_limit_30d", "had_limit_80d", "max_abs_change_15d", "no_limit_down_20d",
+        "is_market_height", "new_space_board", "max_continuous_board_10d",
+        "dragon_first_yin", "yin_day_pct", "broken_reversal", "days_since_broken",
+        "close_above_broken_high", "recent_limit_up_5d",
+    ],
+    "竞价因子": [
+        "auction_change", "auction_amount_million", "auction_turnover_rate", "auction_volume_ratio",
+    ],
+    "估值规模": [
+        "circ_mv_billion", "total_mv_billion", "pe_ttm", "pb", "ps_ttm",
+        "dividend_yield_ttm", "dividend_years",
+    ],
+    "财务质量": [
+        "roe", "roa", "roic", "gross_margin", "netprofit_yoy", "revenue_yoy",
+        "ocf_to_opincome", "financial_risk",
+        "earnings_surprise_pct", "earnings_days_since_announce", "earnings_event_quality",
+    ],
+    "特色数据": [
+        "popularity_score", "popularity_rank_change", "popularity_dual_source",
+        "institution_net_buy_million", "institution_seat_count",
+        "style_size_fit", "style_growth_fit", "style_fit_score",
+        "factor_value_score", "factor_growth_score", "factor_quality_score",
+        "factor_momentum_score", "factor_sentiment_score", "multi_factor_composite",
+    ],
+}
+
+ALLOWED_OPERATORS = {">", ">=", "<", "<=", "==", "!=", "between", "in"}
+
+
+BUILTIN_STRATEGIES = [
+    {
+        "name": "冰点抗跌先手",
+        "description": "寻找冰点中保持相对强度、低波动且有板块承接的个股，允许无结果。",
+        "regimes": ["ice"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [-3, 7]},
+                {"field": "return_5d", "op": ">=", "value": -5},
+                {"field": "amount_billion", "op": ">=", "value": 1},
+                {"field": "volatility_10d", "op": "<=", "value": 7},
+            ],
+            "score": [
+                {"field": "relative_strength", "weight": 0.30, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.25, "direction": "desc"},
+                {"field": "volume_ratio_5d", "weight": 0.20, "direction": "desc"},
+                {"field": "volatility_10d", "weight": 0.15, "direction": "asc"},
+                {"field": "amount_billion", "weight": 0.10, "direction": "desc"},
+            ],
+            "limit": 12,
+            "min_score": 0.58,
+        },
+    },
+    {
+        "name": "修复先锋",
+        "description": "筛选率先站回趋势、温和放量并获得板块共振的修复前排。",
+        "regimes": ["repair"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [1, 9.7]},
+                {"field": "return_5d", "op": ">", "value": 0},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "volume_ratio_5d", "op": ">=", "value": 1.05},
+            ],
+            "score": [
+                {"field": "sector_strength", "weight": 0.28, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.24, "direction": "desc"},
+                {"field": "volume_ratio_5d", "weight": 0.18, "direction": "desc"},
+                {"field": "net_flow_million", "weight": 0.16, "direction": "desc"},
+                {"field": "amount_billion", "weight": 0.14, "direction": "desc"},
+            ],
+            "limit": 15,
+            "min_score": 0.54,
+        },
+    },
+    {
+        "name": "主线发酵跟随",
+        "description": "在主线扩散期寻找趋势、成交承载和板块涨停梯队共同增强的个股。",
+        "regimes": ["fermentation"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [0, 9.8]},
+                {"field": "return_5d", "op": ">=", "value": 3},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "amount_billion", "op": ">=", "value": 2},
+            ],
+            "score": [
+                {"field": "sector_limit_count", "weight": 0.25, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.24, "direction": "desc"},
+                {"field": "return_10d", "weight": 0.20, "direction": "desc"},
+                {"field": "amount_billion", "weight": 0.16, "direction": "desc"},
+                {"field": "large_flow_million", "weight": 0.15, "direction": "desc"},
+            ],
+            "limit": 15,
+            "min_score": 0.55,
+        },
+    },
+    {
+        "name": "高潮核心去后排",
+        "description": "高潮阶段只保留容量、趋势和辨识度较高的核心，降低后排跟风权重。",
+        "regimes": ["climax"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [-2, 7]},
+                {"field": "return_10d", "op": ">=", "value": 5},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "amount_billion", "op": ">=", "value": 5},
+            ],
+            "score": [
+                {"field": "amount_billion", "weight": 0.28, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.22, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.20, "direction": "desc"},
+                {"field": "volatility_10d", "weight": 0.15, "direction": "asc"},
+                {"field": "limit_streak", "weight": 0.15, "direction": "desc"},
+            ],
+            "limit": 10,
+            "min_score": 0.62,
+        },
+    },
+    {
+        "name": "分化承接回流",
+        "description": "寻找分化中仍有趋势承接、板块强度和资金回流的核心候选。",
+        "regimes": ["divergence"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [-3, 7]},
+                {"field": "return_5d", "op": ">", "value": 0},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "volume_ratio_5d", "op": "between", "value": [0.7, 3.5]},
+            ],
+            "score": [
+                {"field": "relative_strength", "weight": 0.28, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.24, "direction": "desc"},
+                {"field": "net_flow_million", "weight": 0.20, "direction": "desc"},
+                {"field": "volatility_10d", "weight": 0.16, "direction": "asc"},
+                {"field": "amount_billion", "weight": 0.12, "direction": "desc"},
+            ],
+            "limit": 12,
+            "min_score": 0.57,
+        },
+    },
+    {
+        "name": "退潮防守观察",
+        "description": "退潮期采用高门槛防守筛选，结果为空代表当前不宜主动出击。",
+        "regimes": ["retreat"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 180},
+            "filters": [
+                {"field": "pct_chg", "op": "between", "value": [-2, 4]},
+                {"field": "return_5d", "op": ">=", "value": -2},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "volatility_10d", "op": "<=", "value": 4.5},
+                {"field": "amount_billion", "op": ">=", "value": 2},
+            ],
+            "score": [
+                {"field": "volatility_10d", "weight": 0.30, "direction": "asc"},
+                {"field": "relative_strength", "weight": 0.25, "direction": "desc"},
+                {"field": "amount_billion", "weight": 0.20, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.15, "direction": "desc"},
+                {"field": "net_flow_million", "weight": 0.10, "direction": "desc"},
+            ],
+            "limit": 8,
+            "min_score": 0.68,
+        },
+    },
+    {
+        "name": "竞价强势确认",
+        "description": "用竞价涨幅、成交承载和量比确认修复或发酵阶段的主动进攻标的。",
+        "regimes": ["repair", "fermentation", "divergence"],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "auction_change", "op": "between", "value": [1, 7]},
+                {"field": "auction_amount_million", "op": ">=", "value": 3},
+                {"field": "auction_volume_ratio", "op": ">=", "value": 0.8},
+                {"field": "amount_billion", "op": ">=", "value": 1},
+            ],
+            "score": [
+                {"field": "auction_amount_million", "weight": 0.26, "direction": "desc"},
+                {"field": "auction_volume_ratio", "weight": 0.22, "direction": "desc"},
+                {"field": "auction_change", "weight": 0.18, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.18, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.16, "direction": "desc"},
+            ],
+            "limit": 15,
+            "min_score": 0.56,
+        },
+    },
+]
+
+for _strategy in BUILTIN_STRATEGIES:
+    _strategy["formula"].setdefault("meta", {
+        "library": "smart", "category": "周期策略", "quality": "系统",
+        "frequency": "每日", "risk": "随市场阶段", "data_group": "行情因子",
+    })
+
+
+CURATED_STRATEGIES = [
+    {
+        "name": "连续分红质量",
+        "description": "寻找持续派息、盈利质量稳定且波动可控的长期现金回报型公司。",
+        "regimes": list(REGIMES),
+        "formula": {
+            "meta": {"library": "curated", "category": "红利价值", "quality": "A", "frequency": "月度", "risk": "中低", "data_group": "估值与财务"},
+            "universe": {"exclude_st": True, "listed_days_min": 1095},
+            "filters": [
+                {"field": "dividend_years", "op": ">=", "value": 4},
+                {"field": "dividend_yield_ttm", "op": ">=", "value": 2},
+                {"field": "roe", "op": ">=", "value": 6},
+                {"field": "pb", "op": "between", "value": [0.1, 4]},
+            ],
+            "score": [
+                {"field": "dividend_yield_ttm", "weight": 0.30, "direction": "desc"},
+                {"field": "roe", "weight": 0.24, "direction": "desc"},
+                {"field": "ocf_to_opincome", "weight": 0.18, "direction": "desc"},
+                {"field": "volatility_10d", "weight": 0.16, "direction": "asc"},
+                {"field": "total_mv_billion", "weight": 0.12, "direction": "desc"},
+            ], "limit": 20, "min_score": 0.52,
+        },
+    },
+    {
+        "name": "ROIC质量低波",
+        "description": "以投入资本回报、毛利率和估值为核心，寻找低波动的高质量公司。",
+        "regimes": ["ice", "repair", "divergence", "retreat"],
+        "formula": {
+            "meta": {"library": "curated", "category": "质量价值", "quality": "A-", "frequency": "月度", "risk": "中低", "data_group": "估值与财务"},
+            "universe": {"exclude_st": True, "listed_days_min": 730},
+            "filters": [
+                {"field": "roic", "op": ">=", "value": 6},
+                {"field": "gross_margin", "op": ">=", "value": 15},
+                {"field": "pe_ttm", "op": "between", "value": [1, 45]},
+                {"field": "amount_billion", "op": ">=", "value": 1},
+            ],
+            "score": [
+                {"field": "roic", "weight": 0.28, "direction": "desc"},
+                {"field": "gross_margin", "weight": 0.22, "direction": "desc"},
+                {"field": "ps_ttm", "weight": 0.18, "direction": "asc"},
+                {"field": "volatility_10d", "weight": 0.18, "direction": "asc"},
+                {"field": "total_mv_billion", "weight": 0.14, "direction": "desc"},
+            ], "limit": 20, "min_score": 0.54,
+        },
+    },
+    {
+        "name": "低估值现金流白马",
+        "description": "筛选估值克制、经营现金流健康、资产回报稳定的大中型公司。",
+        "regimes": ["ice", "repair", "divergence", "retreat"],
+        "formula": {
+            "meta": {"library": "curated", "category": "现金流价值", "quality": "A-", "frequency": "月度", "risk": "中低", "data_group": "估值与财务"},
+            "universe": {"exclude_st": True, "listed_days_min": 730},
+            "filters": [
+                {"field": "pb", "op": "between", "value": [0.1, 1.8]},
+                {"field": "roa", "op": ">=", "value": 3},
+                {"field": "ocf_to_opincome", "op": ">", "value": 0},
+                {"field": "netprofit_yoy", "op": ">=", "value": -15},
+                {"field": "total_mv_billion", "op": ">=", "value": 100},
+            ],
+            "score": [
+                {"field": "roa", "weight": 0.26, "direction": "desc"},
+                {"field": "ocf_to_opincome", "weight": 0.24, "direction": "desc"},
+                {"field": "pb", "weight": 0.20, "direction": "asc"},
+                {"field": "total_mv_billion", "weight": 0.16, "direction": "desc"},
+                {"field": "volatility_10d", "weight": 0.14, "direction": "asc"},
+            ], "limit": 20, "min_score": 0.53,
+        },
+    },
+    {
+        "name": "高增长合理估值",
+        "description": "在收入和利润同步增长的公司中，优先选择估值合理、趋势得到确认的标的。",
+        "regimes": ["repair", "fermentation", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "成长质量", "quality": "B+", "frequency": "月度", "risk": "中", "data_group": "估值与财务"},
+            "universe": {"exclude_st": True, "listed_days_min": 365},
+            "filters": [
+                {"field": "pe_ttm", "op": "between", "value": [1, 35]},
+                {"field": "revenue_yoy", "op": ">=", "value": 10},
+                {"field": "netprofit_yoy", "op": ">=", "value": 15},
+                {"field": "roe", "op": ">=", "value": 5},
+                {"field": "amount_billion", "op": ">=", "value": 1},
+            ],
+            "score": [
+                {"field": "netprofit_yoy", "weight": 0.27, "direction": "desc"},
+                {"field": "revenue_yoy", "weight": 0.23, "direction": "desc"},
+                {"field": "roe", "weight": 0.20, "direction": "desc"},
+                {"field": "pe_ttm", "weight": 0.16, "direction": "asc"},
+                {"field": "relative_strength", "weight": 0.14, "direction": "desc"},
+            ], "limit": 20, "min_score": 0.55,
+        },
+    },
+    {
+        "name": "行业宽度主线",
+        "description": "从行业站上20日线的覆盖率和板块强度出发，筛选主线中的强势个股。",
+        "regimes": ["repair", "fermentation", "climax", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "行业轮动", "quality": "B+", "frequency": "每周", "risk": "中", "data_group": "行情与行业"},
+            "universe": {"exclude_st": True, "listed_days_min": 180},
+            "filters": [
+                {"field": "sector_breadth_ma20", "op": ">=", "value": 55},
+                {"field": "sector_strength", "op": ">=", "value": 55},
+                {"field": "above_ma20", "op": "==", "value": 1},
+                {"field": "amount_billion", "op": ">=", "value": 2},
+            ],
+            "score": [
+                {"field": "sector_breadth_ma20", "weight": 0.28, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.24, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.20, "direction": "desc"},
+                {"field": "sector_limit_count", "weight": 0.16, "direction": "desc"},
+                {"field": "amount_billion", "weight": 0.12, "direction": "desc"},
+            ], "limit": 20, "min_score": 0.56,
+        },
+    },
+    {
+        "name": "首板低开",
+        "description": "昨日首板且位置不高，次日竞价温和低开并具备成交承载时进入候选。",
+        "regimes": ["ice", "repair", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "短线竞价", "quality": "B+", "frequency": "每日9:25", "risk": "高", "data_group": "行情与竞价"},
+            "universe": {"exclude_st": True, "listed_days_min": 250},
+            "filters": [
+                {"field": "previous_first_limit", "op": "==", "value": 1},
+                {"field": "auction_change", "op": "between", "value": [-4.5, -2.5]},
+                {"field": "relative_position_60", "op": "<=", "value": 0.55},
+                {"field": "previous_amount_billion", "op": ">=", "value": 1},
+            ],
+            "score": [
+                {"field": "auction_amount_million", "weight": 0.28, "direction": "desc"},
+                {"field": "previous_amount_billion", "weight": 0.24, "direction": "desc"},
+                {"field": "relative_position_60", "weight": 0.20, "direction": "asc"},
+                {"field": "sector_strength", "weight": 0.16, "direction": "desc"},
+                {"field": "auction_volume_ratio", "weight": 0.12, "direction": "desc"},
+            ], "limit": 12, "min_score": 0.50,
+        },
+    },
+    {
+        "name": "小碎步临界突破",
+        "description": "寻找近期窄幅爬升、接近阶段高点且具备历史活跃记忆的突破候选。",
+        "regimes": ["repair", "fermentation", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "形态突破", "quality": "B+", "frequency": "每日", "risk": "中高", "data_group": "历史行情"},
+            "universe": {"exclude_st": True, "listed_days_min": 250},
+            "filters": [
+                {"field": "no_limit_30d", "op": "==", "value": 1},
+                {"field": "had_limit_80d", "op": "==", "value": 1},
+                {"field": "max_abs_change_15d", "op": "<=", "value": 3},
+                {"field": "close_to_high_15d", "op": ">=", "value": 0.98},
+                {"field": "close_to_high_60d", "op": ">=", "value": 0.90},
+            ],
+            "score": [
+                {"field": "close_to_high_15d", "weight": 0.26, "direction": "desc"},
+                {"field": "volume_ratio_5d", "weight": 0.22, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.20, "direction": "desc"},
+                {"field": "max_abs_change_15d", "weight": 0.18, "direction": "asc"},
+                {"field": "circ_mv_billion", "weight": 0.14, "direction": "asc"},
+            ], "limit": 15, "min_score": 0.54,
+        },
+    },
+    {
+        "name": "连板龙头",
+        "description": "从昨日连板梯队中按高度、板块热度和成交承载筛选辨识度前排。",
+        "regimes": ["fermentation", "climax", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "连板接力", "quality": "B", "frequency": "每日", "risk": "很高", "data_group": "涨停结构"},
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "previous_limit_streak", "op": ">=", "value": 2},
+                {"field": "previous_amount_billion", "op": ">=", "value": 1},
+            ],
+            "score": [
+                {"field": "previous_limit_streak", "weight": 0.34, "direction": "desc"},
+                {"field": "sector_limit_count", "weight": 0.24, "direction": "desc"},
+                {"field": "previous_amount_billion", "weight": 0.18, "direction": "desc"},
+                {"field": "turnover_rate", "weight": 0.14, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.10, "direction": "desc"},
+            ], "limit": 10, "min_score": 0.50,
+        },
+    },
+    {
+        "name": "微盘三正",
+        "description": "以正估值、正盈利和正经营现金流约束微盘暴露，保留明确风险提示。",
+        "regimes": ["repair", "fermentation"],
+        "formula": {
+            "meta": {"library": "curated", "category": "小盘质量", "quality": "B", "frequency": "每周", "risk": "高", "data_group": "估值与财务"},
+            "universe": {"exclude_st": True, "listed_days_min": 365},
+            "filters": [
+                {"field": "pb", "op": ">", "value": 0},
+                {"field": "roe", "op": ">", "value": 0},
+                {"field": "ocf_to_opincome", "op": ">", "value": 0},
+                {"field": "circ_mv_billion", "op": "between", "value": [5, 100]},
+                {"field": "amount_billion", "op": ">=", "value": 0.5},
+            ],
+            "score": [
+                {"field": "circ_mv_billion", "weight": 0.32, "direction": "asc"},
+                {"field": "roe", "weight": 0.24, "direction": "desc"},
+                {"field": "ocf_to_opincome", "weight": 0.20, "direction": "desc"},
+                {"field": "turnover_rate", "weight": 0.14, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.10, "direction": "desc"},
+            ], "limit": 20, "min_score": 0.52,
+        },
+    },
+    {
+        "name": "首板高开弱转强",
+        "description": "昨日涨停或触板后，使用9:25最终竞价涨幅、量比和板块承接确认强度。",
+        "regimes": ["repair", "fermentation", "divergence"],
+        "formula": {
+            "meta": {"library": "curated", "category": "短线竞价", "quality": "B-", "frequency": "每日9:25", "risk": "高", "data_group": "行情与竞价"},
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [
+                {"field": "previous_limit_signal", "op": "==", "value": 1},
+                {"field": "auction_change", "op": "between", "value": [1, 6]},
+                {"field": "auction_volume_ratio", "op": ">=", "value": 0.8},
+                {"field": "previous_amount_billion", "op": "between", "value": [3, 25]},
+            ],
+            "score": [
+                {"field": "auction_amount_million", "weight": 0.28, "direction": "desc"},
+                {"field": "auction_volume_ratio", "weight": 0.24, "direction": "desc"},
+                {"field": "auction_change", "weight": 0.18, "direction": "desc"},
+                {"field": "sector_strength", "weight": 0.17, "direction": "desc"},
+                {"field": "relative_strength", "weight": 0.13, "direction": "desc"},
+            ], "limit": 15, "min_score": 0.52,
+        },
+    },
+]
+
+CURATED_STRATEGIES.extend(ADVANCED_CURATED_STRATEGIES)
+
+STRATEGY_ENVIRONMENT_NOTES = {
+    "连续分红质量": (
+        "防守市、低利率环境与中长期配置窗口",
+        "风险偏好快速上升时，稳健资产的价格弹性通常落后",
+    ),
+    "ROIC质量低波": (
+        "震荡偏弱、重视盈利质量与回撤控制的市场",
+        "主题快速扩散或高弹性行情中，低波筛选可能错过进攻方向",
+    ),
+    "低估值现金流白马": (
+        "估值修复、价值回归及防守配置阶段",
+        "低估值可能来自基本面持续走弱，需警惕价值陷阱",
+    ),
+    "高增长合理估值": (
+        "业绩驱动、成长风格占优且趋势获得确认的阶段",
+        "增长预期下修或估值快速收缩时，回撤可能明显放大",
+    ),
+    "行业宽度主线": (
+        "主线清晰、行业内部多数个股同步走强的行情",
+        "板块快速轮动时，宽度信号容易在确认后迅速衰减",
+    ),
+    "首板低开": (
+        "情绪修复期的分歧转一致与首板次日承接",
+        "退潮加速或低开缺少量能承接时，弱势可能继续扩大",
+    ),
+    "小碎步临界突破": (
+        "趋势蓄势、波动收敛后临近突破的结构市",
+        "无量突破或指数剧烈震荡时，容易形成冲高回落",
+    ),
+    "连板龙头": (
+        "高度拓展、题材梯队完整且接力情绪活跃的阶段",
+        "亏钱效应扩散或高位股集中退潮时，接力风险很高",
+    ),
+    "微盘三正": (
+        "小盘风格活跃、流动性宽松且风险偏好较高的行情",
+        "风格切向大盘或微盘流动性收缩时，组合波动会显著上升",
+    ),
+    "首板高开弱转强": (
+        "竞价承接明确、短线情绪修复或主线发酵阶段",
+        "高开缺乏板块共振时，竞价强势可能转为盘中兑现",
+    ),
+    "中期动量·强者恒强": (
+        "趋势延续、主升段及强弱分化清晰的行情",
+        "无趋势震荡或快速轮动中，动量信号容易反复失效",
+    ),
+    "强者回调": (
+        "主升趋势未破、强势股完成良性回踩的窗口",
+        "趋势已反转时，回调信号可能演变为下跌中继",
+    ),
+    "超跌反转": (
+        "急跌后恐慌释放充分、市场进入修复预期的阶段",
+        "单边下跌初段容易过早介入，超跌不等于止跌",
+    ),
+    "相对强度新高": (
+        "指数偏弱但结构性主线明确，或机构抱团强化的行情",
+        "基准快速补涨或强势方向瓦解时，相对优势可能迅速消失",
+    ),
+    "均线多头排列": (
+        "中期趋势向上、回撤有序的趋势市与主升段",
+        "高位趋势末端或宽幅震荡中，均线信号通常反应滞后",
+    ),
+    "唐奇安通道突破": (
+        "整理末端、放量突破并启动新趋势的行情",
+        "无量突破和宽幅震荡环境中，假突破出现概率较高",
+    ),
+    "周线趋势·日线买点": (
+        "中期趋势稳定、日线回踩或再启动的多周期共振阶段",
+        "周线拐点尚未确认时，日线信号可能只是短暂反抽",
+    ),
+    "空间板": (
+        "市场高度持续拓展、板块梯队完整的强接力环境",
+        "高度压缩或亏钱效应扩散时，最高板的补跌风险极高",
+    ),
+    "龙头首阴": (
+        "主线龙头仍有辨识度、首次分歧后存在回流预期的阶段",
+        "题材退潮或龙头地位被替代后，首阴可能只是下跌起点",
+    ),
+    "断板反包": (
+        "强势题材分歧后快速修复、核心股重新获得资金承接时",
+        "板块强度不足或反包缩量时，形态持续性通常较弱",
+    ),
+    "核按钮反核": (
+        "恐慌释放后出现明确承接、短线情绪转暖的窗口",
+        "系统性退潮中深水拉回可能只是日内脉冲，隔日风险较高",
+    ),
+    "行业动量轮动": (
+        "主线相对清晰、行业趋势能够延续两周以上的结构市",
+        "行业轮动速度过快或前三名差距很小时，动量优势容易迅速衰减",
+    ),
+    "主力资金行业流入": (
+        "板块轮动初期、资金先于价格形成连续净流入的阶段",
+        "资金流口径可能受大宗交易和短期对倒影响，单日突增不代表趋势",
+    ),
+    "景气-趋势-拥挤三维行业打分": (
+        "行业景气与价格趋势同向、但交易拥挤尚未达到极端的结构市",
+        "财务披露存在滞后，行业快速反转时三维综合分可能反应偏慢",
+    ),
+    "大小盘/成长价值风格切换(元策略)": (
+        "大小盘或成长价值风格形成持续相对强弱的阶段",
+        "风格快速往返切换时，近20日相对表现容易产生滞后信号",
+    ),
+    "业绩超预期漂移(SUE/PEAD)": (
+        "业绩披露窗口中，快报相对预告继续上修且价格尚未充分兑现时",
+        "预告与快报口径可能不同，公告后高开兑现会削弱漂移效应",
+    ),
+    "多因子综合打分(IC动态加权)": (
+        "因子表现具备一定延续性、市场并非由单一极端主题主导时",
+        "近期有效因子可能快速失效，动态权重不能消除风格突变风险",
+    ),
+    "热度突增潜伏(另类数据)": (
+        "人气快速抬升但股价尚未明显启动的题材萌芽与扩散初期",
+        "榜单热度可能由短期讨论驱动，缺少价格确认时误报率较高",
+    ),
+    "机构榜溢价": (
+        "机构专用席位在相对低位形成明确净买入、且成交承载正常时",
+        "高位机构榜可能对应兑现或对倒，席位净买入不等于持续锁仓",
+    ),
+}
+
+for strategy in CURATED_STRATEGIES:
+    suitable_environment, failure_risk = STRATEGY_ENVIRONMENT_NOTES[strategy["name"]]
+    strategy["formula"]["meta"].update(
+        {
+            "suitable_environment": suitable_environment,
+            "failure_risk": failure_risk,
+        }
+    )
+
+BUILTIN_STRATEGIES.extend(CURATED_STRATEGIES)
+
+for strategy in BUILTIN_STRATEGIES:
+    attach_strategy_validity(strategy)

app/backend/features/screener/compiler.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import json
+from typing import Any
+
+from backend.llm import transport as llm_transport
+from backend.features.screener.catalog import FACTOR_FIELDS, REGIMES
+
+
+class LLMCompilerError(RuntimeError):
+    pass
+
+
+def test_llm_connection(
+    api_key: str,
+    base_url: str,
+    model: str,
+    timeout: int = 30,
+) -> dict[str, Any]:
+    if not api_key or not model:
+        raise LLMCompilerError("API Key 或模型未配置。")
+    try:
+        result = llm_transport.chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=[{"role": "user", "content": "只回复 OK"}],
+            timeout=timeout,
+            user_agent="XiaobaiReviewWeb/0.5",
+        )
+        reply = str(result.content).strip()
+    except llm_transport.OpenAIHTTPError as exc:
+        raise LLMCompilerError(exc.describe("模型连接测试失败")) from exc
+    except llm_transport.OpenAITransportError as exc:
+        raise LLMCompilerError(f"模型连接测试失败：{exc}") from exc
+    return {
+        "ok": True,
+        "model": model,
+        "reply": reply[:100],
+        "latency_ms": result.latency_ms,
+    }
+
+
+def compile_strategy_with_llm(
+    prompt: str,
+    regime: str,
+    api_key: str,
+    base_url: str,
+    model: str,
+    timeout: int = 45,
+) -> dict[str, Any]:
+    if not api_key or not model:
+        raise LLMCompilerError("尚未配置 LLM API Key 或模型。")
+    schema = {
+        "name": "策略名称",
+        "description": "策略说明",
+        "regimes": [regime],
+        "formula": {
+            "universe": {"exclude_st": True, "listed_days_min": 120},
+            "filters": [{"field": "return_5d", "op": ">=", "value": 0}],
+            "score": [{"field": "sector_strength", "weight": 0.3, "direction": "desc"}],
+            "limit": 15,
+            "min_score": 0.55,
+        },
+    }
+    system_prompt = (
+        "你是A股量化策略编译器。只输出JSON对象，不输出Markdown。"
+        "不得生成Python、SQL、网络请求或未提供的因子。"
+        f"当前市场阶段为{REGIMES.get(regime, regime)}。"
+        f"可用因子为：{json.dumps(FACTOR_FIELDS, ensure_ascii=False)}。"
+        "运算符只能使用 >, >=, <, <=, ==, !=, between, in。"
+        "score权重均大于0且不超过1，direction只能是asc或desc。"
+        "退潮和冰点策略必须提高门槛并允许结果为空。"
+        f"严格遵循以下结构：{json.dumps(schema, ensure_ascii=False)}"
+    )
+    try:
+        result = llm_transport.chat_completion(
+            api_key=api_key,
+            base_url=base_url,
+            model=model,
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": prompt[:3000]},
+            ],
+            timeout=timeout,
+            user_agent="XiaobaiReviewWeb/0.4",
+        )
+        content = result.content.strip()
+        if content.startswith("```"):
+            content = content.strip("`")
+            if content.startswith("json"):
+                content = content[4:].strip()
+        compiled = json.loads(content)
+    except llm_transport.OpenAIHTTPError as exc:
+        raise LLMCompilerError(exc.describe("LLM 策略编译失败")) from exc
+    except (llm_transport.OpenAITransportError, json.JSONDecodeError) as exc:
+        raise LLMCompilerError(f"LLM 策略编译失败：{exc}") from exc
+    compiled["compiler"] = "llm"
+    compiled["model"] = model
+    return compiled

app/backend/features/screener/data_sync.py

@@ -0,0 +1,342 @@
+from __future__ import annotations
+
+import statistics
+from datetime import datetime, timedelta
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.data.providers.tushare_client import TushareClient, TushareError
+from backend.features.screener.indicators import _optional_number
+from database import ReviewDatabase
+
+
+def _quarter_periods(trade_date: str, count: int) -> list[str]:
+    current = datetime.strptime(trade_date, "%Y%m%d")
+    quarter_ends = ((3, 31), (6, 30), (9, 30), (12, 31))
+    periods = []
+    year = current.year
+    while len(periods) < count:
+        for month, day in reversed(quarter_ends):
+            value = datetime(year, month, day)
+            if value <= current:
+                periods.append(value.strftime("%Y%m%d"))
+                if len(periods) == count:
+                    break
+        year -= 1
+    return sorted(periods)
+
+
+def _earnings_event_rows(
+    forecasts: list[dict[str, Any]], expresses: list[dict[str, Any]], trade_date: str,
+) -> list[dict[str, Any]]:
+    forecast_map: dict[tuple[str, str], dict[str, Any]] = {}
+    for row in forecasts:
+        key = (str(row.get("ts_code") or ""), str(row.get("end_date") or ""))
+        ann_date = str(row.get("ann_date") or "")
+        if not all(key) or not ann_date or ann_date > trade_date:
+            continue
+        previous = forecast_map.get(key)
+        if previous is None or ann_date > str(previous.get("ann_date") or ""):
+            forecast_map[key] = row
+    result = []
+    for row in expresses:
+        ts_code = str(row.get("ts_code") or "")
+        end_date = str(row.get("end_date") or "")
+        ann_date = str(row.get("ann_date") or "")
+        forecast = forecast_map.get((ts_code, end_date))
+        if not forecast or not ts_code or not end_date or not ann_date or ann_date > trade_date:
+            continue
+        lower = _optional_number(forecast.get("net_profit_min"))
+        upper = _optional_number(forecast.get("net_profit_max"))
+        forecast_profit = statistics.fmean(
+            value for value in (lower, upper) if value is not None
+        ) if lower is not None or upper is not None else None
+        actual_profit = _optional_number(row.get("n_income"))
+        if forecast_profit in (None, 0) or actual_profit is None:
+            continue
+        # forecast is reported in ten-thousand yuan while express uses yuan.
+        if abs(actual_profit) > max(abs(forecast_profit), 1) * 100:
+            actual_profit /= 10000
+        surprise_pct = (actual_profit / forecast_profit - 1) * 100
+        result.append(
+            {
+                "end_date": end_date,
+                "ann_date": ann_date,
+                "ts_code": ts_code,
+                "forecast_profit": forecast_profit,
+                "actual_profit": actual_profit,
+                "surprise_pct": surprise_pct,
+                "revenue_yoy": _optional_number(row.get("yoy_sales")),
+                "netprofit_yoy": _optional_number(row.get("yoy_net_profit")),
+                "source": "forecast+express",
+            }
+        )
+    return result
+
+
+def _popularity_factor_rows(
+    trade_date: str,
+    ths_rows: list[dict[str, Any]],
+    dc_rows: list[dict[str, Any]],
+    previous_ths: list[dict[str, Any]],
+    previous_dc: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    def ranks(rows: list[dict[str, Any]], data_type: str) -> dict[str, int]:
+        result = {}
+        for row in rows:
+            if data_type and str(row.get("data_type") or "") != data_type:
+                continue
+            ts_code = str(row.get("ts_code") or "")
+            rank = int(_number(row.get("rank")))
+            if ts_code and rank > 0:
+                result[ts_code] = rank
+        return result
+
+    ths = ranks(ths_rows, "热股")
+    dc = ranks(dc_rows, "A股市场")
+    previous_ths_map = ranks(previous_ths, "热股")
+    previous_dc_map = ranks(previous_dc, "A股市场")
+    result = []
+    for ts_code in set(ths) | set(dc):
+        ths_rank = ths.get(ts_code)
+        dc_rank = dc.get(ts_code)
+        current_best = min(value for value in (ths_rank, dc_rank) if value is not None)
+        previous_candidates = [
+            value for value in (previous_ths_map.get(ts_code), previous_dc_map.get(ts_code))
+            if value is not None
+        ]
+        previous_best = min(previous_candidates) if previous_candidates else None
+        score = (101 - (ths_rank or 101)) * 0.5 + (201 - (dc_rank or 201)) * 0.25
+        result.append(
+            {
+                "trade_date": trade_date,
+                "ts_code": ts_code,
+                "ths_rank": ths_rank,
+                "dc_rank": dc_rank,
+                "combined_score": round(score, 2),
+                "rank_change": (
+                    previous_best - current_best
+                    if previous_best is not None
+                    else min(30, max(0, 31 - current_best))
+                    if previous_ths_map or previous_dc_map else 0
+                ),
+                "dual_source": bool(ths_rank and dc_rank),
+            }
+        )
+    return result
+
+
+class FactorDataService:
+    def __init__(self, database: ReviewDatabase, client: TushareClient) -> None:
+        self.database = database
+        self.client = client
+
+    def sync(self, requested_date: str, lookback: int = 45) -> dict[str, Any]:
+        lookback = max(25, min(260, int(lookback)))
+        trade_date, _ = self.client.resolve_trade_context(requested_date)
+        end = datetime.strptime(trade_date, "%Y%m%d")
+        start = (end - timedelta(days=max(100, lookback * 2 + 20))).strftime("%Y%m%d")
+        calendar = self.client.query(
+            "trade_cal",
+            {"exchange": "SSE", "start_date": start, "end_date": trade_date, "is_open": 1},
+            "cal_date,is_open",
+        )
+        dates = sorted(row["cal_date"] for row in calendar if row.get("is_open") == 1)[-lookback:]
+        existing = set(self.database.factor_dates(trade_date, lookback + 10))
+        dates_to_fetch = [value for value in dates if value not in existing or value == trade_date]
+        auction_source_dates = dates[-min(80, len(dates)):]
+        existing_auction = set(self.database.auction_factor_dates(trade_date, 90))
+        auction_dates_to_fetch = [
+            value for value in auction_source_dates
+            if value not in existing_auction or value == trade_date
+        ]
+        long_calendar = self.client.query(
+            "trade_cal",
+            {
+                "exchange": "SSE",
+                "start_date": datetime(end.year - 5, 1, 1).strftime("%Y%m%d"),
+                "end_date": trade_date,
+                "is_open": 1,
+            },
+            "cal_date,is_open",
+        )
+        last_open_by_year: dict[str, str] = {}
+        last_open_by_month: dict[str, str] = {}
+        for row in long_calendar:
+            if row.get("is_open") == 1 and row.get("cal_date"):
+                value = str(row["cal_date"])
+                last_open_by_year[value[:4]] = max(last_open_by_year.get(value[:4], ""), value)
+                last_open_by_month[value[:6]] = max(last_open_by_month.get(value[:6], ""), value)
+        valuation_dates = set(dates[-min(80, len(dates)):])
+        valuation_dates.update(last_open_by_year.values())
+        valuation_dates.update(last_open_by_month.values())
+        existing_indicators = set(self.database.daily_indicator_dates(trade_date, 500))
+        indicator_dates_to_fetch = sorted(
+            value for value in valuation_dates if value not in existing_indicators or value == trade_date
+        )
+
+        master = self.client.query(
+            "stock_basic",
+            {"list_status": "L"},
+            "ts_code,name,industry,market,list_date",
+        )
+        master_count = self.database.upsert_stock_master(master)
+        bar_count = 0
+        for current_date in dates_to_fetch:
+            rows = self.client.query(
+                "daily",
+                {"trade_date": current_date},
+                "ts_code,trade_date,open,high,low,close,pct_chg,vol,amount",
+            )
+            bar_count += self.database.upsert_daily_bars(rows)
+
+        indicator_count = 0
+        for current_date in indicator_dates_to_fetch:
+            indicators = self.client.query(
+                "daily_basic",
+                {"trade_date": current_date},
+                "ts_code,trade_date,turnover_rate,volume_ratio,total_mv,circ_mv,"
+                "pe_ttm,pb,ps_ttm,dv_ttm",
+            )
+            indicator_count += self.database.upsert_daily_indicators(indicators)
+
+        notices = []
+        benchmark_count = 0
+        try:
+            benchmark_rows = self.client.query(
+                "index_daily",
+                {"ts_code": "000300.SH", "start_date": dates[0], "end_date": trade_date},
+                "ts_code,trade_date,close,pct_chg",
+            )
+            benchmark_count = self.database.upsert_benchmark_bars(benchmark_rows)
+        except TushareError as exc:
+            notices.append(f"沪深300基准暂不可用：{exc}")
+        fundamental_count = 0
+        existing_periods = set(self.database.fundamental_periods())
+        for period in _quarter_periods(trade_date, 9):
+            if period in existing_periods and period < trade_date[:4] + "0101":
+                continue
+            try:
+                rows = self.client.query(
+                    "fina_indicator_vip",
+                    {"period": period},
+                    "ts_code,ann_date,end_date,roe,roa,roic,grossprofit_margin,"
+                    "netprofit_yoy,or_yoy,ocf_to_opincome",
+                )
+            except TushareError as exc:
+                notices.append(f"财务质量接口不可用：{exc}")
+                break
+            published = [
+                row for row in rows
+                if not row.get("ann_date") or str(row.get("ann_date")) <= trade_date
+            ]
+            published.sort(key=lambda row: str(row.get("ann_date") or ""))
+            fundamental_count += self.database.upsert_fundamental_indicators(published)
+        auction_count = 0
+        auction_dates = 0
+        for current_date in auction_dates_to_fetch:
+            try:
+                auction_rows = self.client.query(
+                    "stk_auction",
+                    {"trade_date": current_date},
+                    "ts_code,trade_date,vol,price,amount,pre_close,turnover_rate,volume_ratio,float_share",
+                )
+                if auction_rows:
+                    auction_count += self.database.upsert_auction_factors(auction_rows)
+                    auction_dates += 1
+            except TushareError as exc:
+                notices.append(f"竞价因子接口不可用：{exc}")
+                break
+        moneyflow_count = 0
+        moneyflow_dates = 0
+        for current_date in dates[-min(5, len(dates)):]:
+            try:
+                moneyflow = self.client.query(
+                    "moneyflow",
+                    {"trade_date": current_date},
+                    "ts_code,trade_date,buy_sm_amount,sell_sm_amount,buy_md_amount,sell_md_amount,"
+                    "buy_lg_amount,sell_lg_amount,buy_elg_amount,sell_elg_amount,net_mf_amount",
+                )
+                moneyflow_count += self.database.upsert_moneyflow(moneyflow)
+                if moneyflow:
+                    moneyflow_dates += 1
+            except TushareError as exc:
+                notices.append(f"资金流接口不可用：{exc}")
+                break
+
+        earnings_count = 0
+        forecasts: list[dict[str, Any]] = []
+        expresses: list[dict[str, Any]] = []
+        for period in _quarter_periods(trade_date, 5):
+            try:
+                forecast_rows = self.client.query(
+                    "forecast_vip",
+                    {"period": period},
+                    "ts_code,ann_date,end_date,net_profit_min,net_profit_max,last_parent_net,p_change_min,p_change_max",
+                )
+                express_rows = self.client.query(
+                    "express_vip",
+                    {"period": period},
+                    "ts_code,ann_date,end_date,n_income,yoy_net_profit,yoy_sales",
+                )
+            except TushareError as exc:
+                notices.append(f"业绩事件接口不可用：{exc}")
+                break
+            forecasts.extend(forecast_rows)
+            expresses.extend(express_rows)
+        if forecasts and expresses:
+            earnings_count = self.database.upsert_earnings_events(
+                _earnings_event_rows(forecasts, expresses, trade_date)
+            )
+
+        popularity_count = 0
+        previous_trade_date = dates[-2] if len(dates) >= 2 else ""
+        try:
+            ths_rows = self.client.query("ths_hot", {"trade_date": trade_date})
+            dc_rows = self.client.query("dc_hot", {"trade_date": trade_date})
+            previous_ths = (
+                self.client.query("ths_hot", {"trade_date": previous_trade_date})
+                if previous_trade_date else []
+            )
+            previous_dc = (
+                self.client.query("dc_hot", {"trade_date": previous_trade_date})
+                if previous_trade_date else []
+            )
+            popularity_count = self.database.upsert_popularity_factors(
+                _popularity_factor_rows(
+                    trade_date, ths_rows, dc_rows, previous_ths, previous_dc
+                )
+            )
+        except TushareError as exc:
+            notices.append(f"人气榜因子不可用：{exc}")
+
+        institution_count = 0
+        try:
+            institution_rows = self.client.query(
+                "top_inst",
+                {"trade_date": trade_date},
+                "trade_date,ts_code,exalter,buy,sell,net_buy,side,reason",
+            )
+            institution_count = self.database.upsert_lhb_institutions(institution_rows)
+        except TushareError as exc:
+            notices.append(f"机构席位明细不可用：{exc}")
+
+        return {
+            "trade_date": trade_date,
+            "calendar_dates": len(dates),
+            "fetched_dates": len(dates_to_fetch),
+            "stocks": master_count,
+            "bars": bar_count,
+            "benchmark_bars": benchmark_count,
+            "indicators": indicator_count,
+            "indicator_dates": len(indicator_dates_to_fetch),
+            "fundamentals": fundamental_count,
+            "moneyflow": moneyflow_count,
+            "moneyflow_dates": moneyflow_dates,
+            "auction_rows": auction_count,
+            "auction_dates": auction_dates,
+            "earnings_events": earnings_count,
+            "popularity_rows": popularity_count,
+            "institution_rows": institution_count,
+            "notice": "；".join(notices),
+        }

app/backend/features/screener/engine.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.bootstrap.config import display_compact_date as _display_date
+from backend.data.numbers import finite_number as _number
+from backend.features.screener.backtest import BacktestRunner
+from backend.features.screener.catalog import (
+    ADVANCED_CURATED_STRATEGIES,
+    ALLOWED_OPERATORS,
+    BUILTIN_STRATEGIES,
+    CURATED_STRATEGIES,
+    FACTOR_FIELDS,
+    FACTOR_GROUPS,
+    REGIMES,
+    STRATEGY_ENVIRONMENT_NOTES,
+)
+from backend.features.screener.data_sync import (
+    FactorDataService,
+    _earnings_event_rows,
+    _popularity_factor_rows,
+    _quarter_periods,
+)
+from backend.features.screener.factors import FactorBuilder
+from backend.features.screener.formula import FormulaEvaluator, compile_local_strategy
+from backend.features.screener.indicators import (
+    _available_percentile_map,
+    _broken_reversal_metrics,
+    _ema,
+    _ending_streak,
+    _is_limit_bar,
+    _limit_threshold,
+    _macd_last,
+    _macd_series,
+    _matches,
+    _max_streak,
+    _optional_number,
+    _pearson,
+    _percentile_map,
+    _regime_reason,
+    _risk_flags,
+    _rounded_optional,
+    _rsi,
+    _touched_limit_bar,
+    _weekly_series,
+)
+from backend.features.screener.regime import RegimeDetector
+from backend.features.screener.selection import SelectionRunner
+from database import ReviewDatabase
+
+
+class ScreenerEngine:
+    """Stable facade over the independently owned screener services."""
+
+    def __init__(self, database: ReviewDatabase) -> None:
+        self.database = database
+        self.factor_builder = FactorBuilder(database)
+        self.formula_evaluator = FormulaEvaluator()
+        self.regime_detector = RegimeDetector(database)
+        self.backtest_runner = BacktestRunner(
+            database, self.factor_builder, self.formula_evaluator
+        )
+        self.selection_runner = SelectionRunner(
+            database,
+            self.factor_builder,
+            self.formula_evaluator,
+            self.backtest_runner,
+        )
+
+    def ensure_builtin_strategies(self) -> None:
+        existing = {
+            item["name"]: item
+            for item in self.database.list_screener_strategies()
+            if item["builtin"]
+        }
+        for strategy in BUILTIN_STRATEGIES:
+            current = existing.get(strategy["name"])
+            self.database.save_screener_strategy(
+                None, **strategy, builtin=True,
+                strategy_id=int(current["id"]) if current else None,
+            )
+
+    def detect_regime(self, trade_date: str) -> dict[str, Any]:
+        return self.regime_detector.detect_regime(trade_date)
+
+    def factor_health(self, trade_date: str) -> dict[str, Any]:
+        return self.database.factor_health_summary(trade_date)
+
+    def validate_formula(self, formula: dict[str, Any]) -> dict[str, Any]:
+        return self.formula_evaluator.validate_formula(formula)
+
+    def screen(
+        self, user_id: int, trade_date: str, formula: dict[str, Any], regime: str,
+        strategy_name: str, run_backtest: bool = True,
+        realtime_snapshot: dict[str, Any] | None = None,
+        mode: str = "smart",
+        prepared_factors: list[dict[str, Any]] | None = None,
+        prepared_date: str = "",
+    ) -> dict[str, Any]:
+        return self.selection_runner.screen(
+            user_id,
+            trade_date,
+            formula,
+            regime,
+            strategy_name,
+            run_backtest,
+            realtime_snapshot,
+            mode,
+            prepared_factors,
+            prepared_date,
+        )
+
+    def build_factors(
+        self,
+        trade_date: str,
+        realtime_snapshot: dict[str, Any] | None = None,
+        history_days: int = 80,
+    ) -> tuple[list[dict[str, Any]], str]:
+        return self.factor_builder.build_factors(
+            trade_date, realtime_snapshot, history_days
+        )
+
+    def apply_formula(
+        self, rows: list[dict[str, Any]], formula: dict[str, Any], regime: str
+    ) -> list[dict[str, Any]]:
+        return self.formula_evaluator.apply_formula(rows, formula, regime)
+
+    def backtest(self, trade_date: str, formula: dict[str, Any]) -> dict[str, Any]:
+        return self.backtest_runner.backtest(trade_date, formula)

app/backend/features/screener/factors.py

@@ -0,0 +1,562 @@
+from __future__ import annotations
+
+import statistics
+from collections import defaultdict
+from datetime import datetime
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.features.screener.indicators import (
+    _available_percentile_map,
+    _broken_reversal_metrics,
+    _ending_streak,
+    _is_limit_bar,
+    _limit_threshold,
+    _macd_last,
+    _macd_series,
+    _max_streak,
+    _optional_number,
+    _pearson,
+    _percentile_map,
+    _rounded_optional,
+    _rsi,
+    _touched_limit_bar,
+    _weekly_series,
+)
+from database import ReviewDatabase
+
+
+class FactorBuilder:
+    def __init__(self, database: ReviewDatabase) -> None:
+        self.database = database
+
+    def build_factors(
+        self,
+        trade_date: str,
+        realtime_snapshot: dict[str, Any] | None = None,
+        history_days: int = 80,
+    ) -> tuple[list[dict[str, Any]], str]:
+        history_days = max(21, min(260, int(history_days)))
+        data = self.database.load_factor_data(trade_date, history_days)
+        dates = [value for value in data["dates"] if value <= trade_date]
+        if len(dates) < 21:
+            raise ValueError("历史行情不足 21 个交易日，请先同步因子数据。")
+        history_date = dates[-1]
+        realtime_map = {
+            str(row.get("ts_code") or ""): row
+            for row in (realtime_snapshot or {}).get("rows") or []
+        }
+        realtime_date = str((realtime_snapshot or {}).get("trade_date") or "")
+        use_realtime = bool(realtime_map and realtime_date == trade_date and history_date < trade_date)
+        actual_date = trade_date if use_realtime else history_date
+        master = {row["ts_code"]: row for row in data["master"]}
+        indicators = {row["ts_code"]: row for row in data["indicators"]}
+        fundamentals = {row["ts_code"]: row for row in data.get("fundamentals", [])}
+        indicator_history: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in data.get("indicator_history", []):
+            indicator_history[str(row.get("ts_code") or "")].append(row)
+        indicator_series: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in data.get("indicator_series", []):
+            indicator_series[str(row.get("ts_code") or "")].append(row)
+        benchmark_by_date = {
+            str(row.get("trade_date") or ""): _number(row.get("close"))
+            for row in data.get("benchmarks", [])
+            if _number(row.get("close")) > 0
+        }
+        moneyflow = {row["ts_code"]: row for row in data["moneyflow"]}
+        moneyflow_history: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in data.get("moneyflow_history", []):
+            moneyflow_history[str(row.get("ts_code") or "")].append(row)
+        auction = {
+            row["ts_code"]: row
+            for row in data.get("auction", [])
+            if str(row.get("trade_date") or "") == actual_date
+        }
+        earnings_events: dict[str, dict[str, Any]] = {}
+        for row in data.get("earnings_events", []):
+            ts_code = str(row.get("ts_code") or "")
+            ann_date = str(row.get("ann_date") or "")
+            if ann_date <= actual_date and (
+                ts_code not in earnings_events
+                or ann_date > str(earnings_events[ts_code].get("ann_date") or "")
+            ):
+                earnings_events[ts_code] = row
+        popularity = {
+            str(row.get("ts_code") or ""): row
+            for row in data.get("popularity", [])
+        }
+        institutions = {
+            str(row.get("ts_code") or ""): row
+            for row in data.get("institutions", [])
+        }
+        grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in data["bars"]:
+            if row["trade_date"] <= history_date:
+                grouped[row["ts_code"]].append(row)
+
+        snapshot = self.database.get_snapshot(actual_date) or {}
+        limit_map: dict[str, tuple[str, int]] = {}
+        for key, status in (("limits", "涨停"), ("broken", "炸板"), ("down_limits", "跌停")):
+            for row in snapshot.get(key) or []:
+                limit_map[str(row.get("code"))] = (status, int(row.get("streak") or 0))
+
+        factors = []
+        current_day = datetime.strptime(actual_date, "%Y%m%d")
+        for ts_code, bars in grouped.items():
+            bars.sort(key=lambda item: item["trade_date"])
+            if len(bars) < 21 or bars[-1]["trade_date"] != history_date:
+                continue
+            info = master.get(ts_code)
+            if not info:
+                continue
+            historical_closes = [_number(item["close"]) for item in bars]
+            historical_volumes = [_number(item["vol"]) for item in bars]
+            realtime = realtime_map.get(ts_code) if use_realtime else None
+            current = realtime or bars[-1]
+            closes = historical_closes + ([_number(realtime["close"])] if realtime else [])
+            volumes = historical_volumes + ([_number(realtime["vol"])] if realtime else [])
+            if closes[-1] <= 0:
+                continue
+            returns_10 = [_number(item["pct_chg"]) for item in bars[-10:]]
+            if realtime:
+                returns_10 = returns_10[-9:] + [_number(realtime.get("pct_chg"))]
+            previous_volume = statistics.fmean(volumes[-6:-1]) if any(volumes[-6:-1]) else 0
+            indicator = indicators.get(ts_code, {})
+            fundamental = fundamentals.get(ts_code, {})
+            flow = moneyflow.get(ts_code, {})
+            flow_history = moneyflow_history.get(ts_code, [])
+            auction_row = auction.get(ts_code, {})
+            list_date = str(info.get("list_date") or "")
+            try:
+                listed_days = (current_day - datetime.strptime(list_date, "%Y%m%d")).days
+            except ValueError:
+                listed_days = 9999
+            code = str(info.get("code") or ts_code.split(".")[0])
+            status, streak = limit_map.get(code, ("", 0))
+            name = str(info.get("name") or "--")
+            shape_rows = bars + ([realtime] if realtime else [])
+            shape_close = [_number(item.get("close")) for item in shape_rows]
+            shape_high = [_number(item.get("high") or item.get("close")) for item in shape_rows]
+            shape_low = [_number(item.get("low") or item.get("close")) for item in shape_rows]
+            shape_changes = [_number(item.get("pct_chg")) for item in shape_rows]
+            position_rows = shape_rows[-60:]
+            position_high = max((_number(item.get("high") or item.get("close")) for item in position_rows), default=0)
+            position_low = min((_number(item.get("low") or item.get("close")) for item in position_rows), default=0)
+            relative_position = (
+                (closes[-1] - position_low) / (position_high - position_low)
+                if position_high > position_low else 0.5
+            )
+            previous_index = len(bars) - 1 if realtime else len(bars) - 2
+            previous_bar = bars[previous_index] if previous_index >= 0 else {}
+            previous_limit = _is_limit_bar(bars, previous_index, code, name)
+            previous_touched = _touched_limit_bar(bars, previous_index, code, name)
+            recent_prior_signal = any(
+                _is_limit_bar(bars, index, code, name)
+                or _touched_limit_bar(bars, index, code, name)
+                for index in range(max(0, previous_index - 2), previous_index)
+            )
+            previous_streak = 0
+            streak_index = previous_index
+            while streak_index >= 0 and _is_limit_bar(bars, streak_index, code, name):
+                previous_streak += 1
+                streak_index -= 1
+            limit_flags = [
+                _is_limit_bar(shape_rows, index, code, name)
+                for index in range(len(shape_rows))
+            ]
+            annual_dividend_rows = indicator_history.get(ts_code, [])
+            dividend_years = sum(
+                1 for item in annual_dividend_rows if _optional_number(item.get("dv_ttm")) not in (None, 0)
+            )
+            current_streak = _ending_streak(limit_flags)
+            prior_streak = _ending_streak(limit_flags, len(limit_flags) - 2)
+            streak = max(streak, current_streak)
+            return_60d = (
+                (closes[-1] / closes[-61] - 1) * 100 if len(closes) >= 61 and closes[-61] else 0
+            )
+            momentum_60_5 = (
+                (closes[-6] / closes[-61] - 1) * 100 if len(closes) >= 61 and closes[-61] else 0
+            )
+            ma20 = statistics.fmean(closes[-20:])
+            ma60 = statistics.fmean(closes[-60:]) if len(closes) >= 60 else ma20
+            prior_ma20 = statistics.fmean(closes[-25:-5]) if len(closes) >= 25 else ma20
+            prior_ma60 = statistics.fmean(closes[-65:-5]) if len(closes) >= 65 else ma60
+            ma20_slope = (ma20 / prior_ma20 - 1) * 100 if prior_ma20 else 0
+            ma60_slope = (ma60 / prior_ma60 - 1) * 100 if prior_ma60 else 0
+            ma_values = [statistics.fmean(closes[-window:]) for window in (5, 10, 20, 60)]
+            high_250 = max(shape_high[-250:]) if len(shape_high) >= 250 else max(shape_high)
+            drawdown_250 = (1 - closes[-1] / high_250) * 100 if high_250 else 100
+            prior_high_20 = max(shape_high[-21:-1]) if len(shape_high) >= 21 else 0
+            breakout_pct = (closes[-1] / prior_high_20 - 1) * 100 if prior_high_20 else 0
+            prior_lows_20 = shape_low[-21:-1]
+            range_20d = (
+                (prior_high_20 / min(prior_lows_20) - 1) * 100
+                if prior_lows_20 and min(prior_lows_20) > 0 else 100
+            )
+            turnover_rows = sorted(
+                indicator_series.get(ts_code, []), key=lambda item: str(item.get("trade_date") or "")
+            )
+            turnover_values = [_number(item.get("turnover_rate")) for item in turnover_rows[-5:]]
+            if realtime and _number(realtime.get("turnover_rate")):
+                turnover_values = turnover_values[-4:] + [_number(realtime.get("turnover_rate"))]
+            turnover_5d = sum(turnover_values)
+            rs_values = [
+                _number(item.get("close")) / benchmark_by_date[str(item.get("trade_date"))]
+                for item in shape_rows[-120:]
+                if benchmark_by_date.get(str(item.get("trade_date"))) and _number(item.get("close")) > 0
+            ]
+            benchmark_60 = [
+                benchmark_by_date.get(str(item.get("trade_date")))
+                for item in shape_rows[-61:]
+                if benchmark_by_date.get(str(item.get("trade_date")))
+            ]
+            benchmark_return_60 = (
+                (benchmark_60[-1] / benchmark_60[0] - 1) * 100
+                if len(benchmark_60) >= 61 and benchmark_60[0] else 0
+            )
+            weekly_closes, weekly_amounts = _weekly_series(shape_rows)
+            weekly_dif, weekly_dea = _macd_last(weekly_closes)
+            daily_dif, daily_dea = _macd_series(closes)
+            daily_cross = (
+                len(daily_dif) >= 2 and daily_dif[-1] > daily_dea[-1]
+                and daily_dif[-2] <= daily_dea[-2]
+            )
+            current_open = _number(current.get("open"))
+            daily_pullback = closes[-1] >= ma20 and current_open <= ma20 * 1.02 and closes[-1] > current_open
+            previous_close = closes[-2] if len(closes) >= 2 else closes[-1]
+            intraday_min = (
+                (_number(current.get("low")) / previous_close - 1) * 100 if previous_close else 0
+            )
+            body = abs(closes[-1] - current_open)
+            lower_shadow = max(0.0, min(current_open, closes[-1]) - _number(current.get("low")))
+            lower_shadow_ratio = lower_shadow / body if body > 0 else (10.0 if lower_shadow > 0 else 0.0)
+            previous_volume_value = volumes[-2] if len(volumes) >= 2 else 0
+            vol_vs_previous = volumes[-1] / previous_volume_value if previous_volume_value else 0
+            broken = _broken_reversal_metrics(shape_rows, limit_flags, code, name)
+            netprofit_yoy = _optional_number(fundamental.get("netprofit_yoy"))
+            earnings_event = earnings_events.get(ts_code, {})
+            announcement_date = str(earnings_event.get("ann_date") or "")
+            earnings_days = (
+                sum(1 for value in dates if announcement_date < value <= actual_date)
+                if announcement_date and announcement_date <= actual_date
+                else None
+            )
+            announcement_bar = next(
+                (item for item in shape_rows if str(item.get("trade_date") or "") == announcement_date),
+                None,
+            )
+            announcement_bad = False
+            if announcement_bar is not None:
+                bar_index = shape_rows.index(announcement_bar)
+                prior_volumes = [
+                    _number(item.get("vol")) for item in shape_rows[max(0, bar_index - 5):bar_index]
+                    if _number(item.get("vol")) > 0
+                ]
+                volume_baseline = statistics.fmean(prior_volumes) if prior_volumes else 0
+                announcement_bad = (
+                    _number(announcement_bar.get("close")) < _number(announcement_bar.get("open"))
+                    and _number(announcement_bar.get("pct_chg")) < 0
+                    and volume_baseline > 0
+                    and _number(announcement_bar.get("vol")) / volume_baseline >= 1.8
+                )
+            popularity_row = popularity.get(ts_code)
+            institution_row = institutions.get(ts_code)
+            factors.append(
+                {
+                    "code": code,
+                    "ts_code": ts_code,
+                    "name": name,
+                    "sector": info.get("industry") or "其他",
+                    "market": info.get("market") or "--",
+                    "listed_days": listed_days,
+                    "close": round(closes[-1], 2),
+                    "price": round(closes[-1], 2),
+                    "pct_chg": round(_number(current["pct_chg"]), 2),
+                    "return_5d": round((closes[-1] / closes[-6] - 1) * 100, 2),
+                    "return_10d": round((closes[-1] / closes[-11] - 1) * 100, 2),
+                    "return_20d": round((closes[-1] / closes[-21] - 1) * 100, 2),
+                    "return_60d": round(return_60d, 2),
+                    "momentum_60_5": round(momentum_60_5, 2),
+                    "above_ma20": int(closes[-1] > ma20),
+                    "rsi_6": round(_rsi(closes, 6), 2),
+                    "ma60_slope": round(ma60_slope, 3),
+                    "ma20_slope_5d": round(ma20_slope, 3),
+                    "ma_bull_alignment": int(ma_values[0] > ma_values[1] > ma_values[2] > ma_values[3]),
+                    "drawdown_from_high_250": round(drawdown_250, 2),
+                    "donchian_breakout_pct": round(breakout_pct, 2),
+                    "range_20d": round(range_20d, 2),
+                    "rs_high_120": int(len(rs_values) >= 120 and rs_values[-1] >= max(rs_values)),
+                    "excess_return_60d": round(return_60d - benchmark_return_60, 2),
+                    "weekly_trend_signal": int(len(weekly_closes) >= 30 and weekly_dif > 0 and weekly_dea > 0),
+                    "daily_buy_trigger": int(daily_cross or daily_pullback),
+                    "weekly_amount_trend": int(
+                        len(weekly_amounts) >= 5
+                        and weekly_amounts[-1] >= statistics.fmean(weekly_amounts[-5:-1])
+                    ),
+                    "volume_ratio_5d": round(volumes[-1] / previous_volume, 2) if previous_volume else 0,
+                    "turnover_5d": round(turnover_5d, 2),
+                    "volatility_10d": round(statistics.pstdev(returns_10), 2),
+                    "amount_billion": round(
+                        _number(current["amount"]) / (100000000 if realtime else 100000), 2
+                    ),
+                    "turnover_rate": round(
+                        _number(realtime.get("turnover_rate"))
+                        if realtime else _number(indicator.get("turnover_rate")),
+                        2,
+                    ),
+                    "circ_mv_billion": round(_number(indicator.get("circ_mv")) / 10000, 2),
+                    "total_mv_billion": round(_number(indicator.get("total_mv")) / 10000, 2),
+                    "pe_ttm": _rounded_optional(indicator.get("pe_ttm"), 2),
+                    "pb": _rounded_optional(indicator.get("pb"), 2),
+                    "ps_ttm": _rounded_optional(indicator.get("ps_ttm"), 2),
+                    "dividend_yield_ttm": _rounded_optional(indicator.get("dv_ttm"), 2),
+                    "dividend_years": dividend_years,
+                    "roe": _rounded_optional(fundamental.get("roe"), 2),
+                    "roa": _rounded_optional(fundamental.get("roa"), 2),
+                    "roic": _rounded_optional(fundamental.get("roic"), 2),
+                    "gross_margin": _rounded_optional(fundamental.get("grossprofit_margin"), 2),
+                    "netprofit_yoy": _rounded_optional(fundamental.get("netprofit_yoy"), 2),
+                    "revenue_yoy": _rounded_optional(fundamental.get("or_yoy"), 2),
+                    "ocf_to_opincome": _rounded_optional(fundamental.get("ocf_to_opincome"), 2),
+                    "earnings_surprise_pct": _rounded_optional(earnings_event.get("surprise_pct"), 2),
+                    "earnings_days_since_announce": earnings_days,
+                    "earnings_event_quality": int(not announcement_bad) if earnings_days is not None else None,
+                    "popularity_score": _rounded_optional(
+                        popularity_row.get("combined_score") if popularity_row else None, 2
+                    ),
+                    "popularity_rank_change": (
+                        int(popularity_row["rank_change"])
+                        if popularity_row and popularity_row.get("rank_change") is not None else None
+                    ),
+                    "popularity_dual_source": (
+                        int(bool(popularity_row.get("dual_source"))) if popularity_row else None
+                    ),
+                    "institution_net_buy_million": (
+                        round(_number(institution_row.get("net_buy_amount")) / 1_000_000, 2)
+                        if institution_row else None
+                    ),
+                    "institution_seat_count": (
+                        int(institution_row.get("seat_count") or 0) if institution_row else None
+                    ),
+                    "net_flow_million": round(_number(flow.get("net_mf_amount")) / 100, 2),
+                    "large_flow_million": round(_number(flow.get("large_net_amount")) / 100, 2),
+                    "net_flow_5d_million": round(
+                        sum(_number(item.get("net_mf_amount")) for item in flow_history) / 100,
+                        2,
+                    ),
+                    "flow_to_circ_mv_5d": round(
+                        sum(_number(item.get("net_mf_amount")) for item in flow_history)
+                        / _number(indicator.get("circ_mv")) * 100,
+                        4,
+                    ) if _number(indicator.get("circ_mv")) else 0,
+                    "limit_status": status,
+                    "limit_streak": streak,
+                    "is_limit_up_today": int(limit_flags[-1]),
+                    "is_limit_down_today": int(_number(current.get("pct_chg")) <= -_limit_threshold(code, name)),
+                    "auction_change": round(_number(auction_row.get("change")), 2),
+                    "auction_amount_million": round(_number(auction_row.get("amount")) / 1_000_000, 2),
+                    "auction_turnover_rate": round(_number(auction_row.get("turnover_rate")), 4),
+                    "auction_volume_ratio": round(_number(auction_row.get("volume_ratio")), 2),
+                    "relative_position_60": round(relative_position, 4),
+                    "max_abs_change_15d": round(max((abs(value) for value in shape_changes[-15:]), default=0), 2),
+                    "close_to_high_15d": round(closes[-1] / max(shape_high[-15:]), 4) if shape_high[-15:] and max(shape_high[-15:]) else 0,
+                    "close_to_high_60d": round(closes[-1] / max(shape_high[-60:]), 4) if shape_high[-60:] and max(shape_high[-60:]) else 0,
+                    "no_limit_30d": int(not any(limit_flags[-30:])),
+                    "had_limit_80d": int(any(limit_flags[-80:-30] if len(limit_flags) > 30 else [])),
+                    "no_limit_down_20d": int(not any(
+                        _number(item.get("pct_chg")) <= -_limit_threshold(code, name)
+                        for item in shape_rows[-20:]
+                    )),
+                    "financial_risk": int(
+                        "ST" in name.upper() or "退" in name
+                        or (netprofit_yoy is not None and netprofit_yoy <= -100)
+                    ),
+                    "prior_limit_streak": prior_streak,
+                    "max_continuous_board_10d": _max_streak(limit_flags[-10:]),
+                    "dragon_first_yin": int(
+                        prior_streak >= 3 and not limit_flags[-1] and closes[-1] < current_open
+                    ),
+                    "yin_day_pct": round(_number(current.get("pct_chg")), 2),
+                    "vol_vs_previous": round(vol_vs_previous, 3),
+                    "broken_reversal": broken["signal"],
+                    "days_since_broken": broken["days"],
+                    "close_above_broken_high": broken["recovered"],
+                    "vol_vs_broken_day": broken["volume_ratio"],
+                    "recent_limit_up_5d": sum(limit_flags[-5:]),
+                    "intraday_min_pct": round(intraday_min, 2),
+                    "lower_shadow_ratio": round(lower_shadow_ratio, 2),
+                    "previous_first_limit": int(previous_limit and not recent_prior_signal),
+                    "previous_limit_signal": int((previous_limit or previous_touched) and not recent_prior_signal),
+                    "previous_limit_streak": previous_streak,
+                    "previous_amount_billion": round(_number(previous_bar.get("amount")) / 100000, 2),
+                }
+            )
+
+        market_return = statistics.fmean(row["return_5d"] for row in factors) if factors else 0
+        sectors: dict[str, list[dict[str, Any]]] = defaultdict(list)
+        for row in factors:
+            sectors[row["sector"]].append(row)
+        sector_metrics = []
+        market_amount = sum(max(0.0, row["amount_billion"]) for row in factors)
+        for sector_name, sector_rows in sectors.items():
+            average_return = statistics.fmean(row["return_5d"] for row in sector_rows)
+            average_return_20d = statistics.fmean(row["return_20d"] for row in sector_rows)
+            sector_net_flow = sum(row["net_flow_5d_million"] for row in sector_rows)
+            limit_count = sum(row["limit_status"] == "涨停" or row["pct_chg"] >= 9.5 for row in sector_rows)
+            up_count = sum(row["pct_chg"] >= 5 for row in sector_rows)
+            breadth_ma20 = sum(row["above_ma20"] for row in sector_rows) / max(len(sector_rows), 1) * 100
+            sector_growth = [
+                statistics.fmean(values)
+                for row in sector_rows
+                if (values := [
+                    value for value in (row.get("revenue_yoy"), row.get("netprofit_yoy"))
+                    if value is not None
+                ])
+            ]
+            prosperity_raw = statistics.median(sector_growth) if sector_growth else -100.0
+            average_turnover = statistics.fmean(row["turnover_rate"] for row in sector_rows)
+            amount_share = (
+                sum(max(0.0, row["amount_billion"]) for row in sector_rows) / market_amount * 100
+                if market_amount else 0.0
+            )
+            crowding_raw = average_turnover + amount_share
+            trend_raw = average_return_20d + breadth_ma20 / 10
+            strength = min(100, max(0, 50 + average_return * 4 + limit_count * 3 + up_count * 0.6))
+            sector_metrics.append(
+                {
+                    "ts_code": sector_name,
+                    "sector_return_20d": average_return_20d,
+                    "sector_net_flow_5d_million": sector_net_flow,
+                    "sector_prosperity_raw": prosperity_raw,
+                    "sector_trend_raw": trend_raw,
+                    "sector_crowding_raw": crowding_raw,
+                }
+            )
+            stock_momentum_ranks = _percentile_map(sector_rows, "return_20d", "desc")
+            for row in sector_rows:
+                row["sector_strength"] = round(strength, 1)
+                row["sector_return_5d"] = round(average_return, 2)
+                row["sector_return_20d"] = round(average_return_20d, 2)
+                row["sector_net_flow_5d_million"] = round(sector_net_flow, 2)
+                row["sector_stock_momentum_rank"] = round(
+                    stock_momentum_ranks.get(row["ts_code"], 0.0), 4
+                )
+                row["sector_limit_count"] = limit_count
+                row["sector_up_count"] = up_count
+                row["sector_breadth_ma20"] = round(breadth_ma20, 1)
+                row["relative_strength"] = round(row["return_5d"] - market_return, 2)
+        sector_momentum_ranks = _percentile_map(
+            sector_metrics, "sector_return_20d", "desc"
+        )
+        sector_flow_ranks = _percentile_map(
+            sector_metrics, "sector_net_flow_5d_million", "desc"
+        )
+        sector_prosperity_ranks = _percentile_map(
+            sector_metrics, "sector_prosperity_raw", "desc"
+        )
+        sector_trend_ranks = _percentile_map(
+            sector_metrics, "sector_trend_raw", "desc"
+        )
+        sector_crowding_ranks = _percentile_map(
+            sector_metrics, "sector_crowding_raw", "desc"
+        )
+        for sector_name, sector_rows in sectors.items():
+            prosperity_rank = sector_prosperity_ranks.get(sector_name, 0.0)
+            trend_rank = sector_trend_ranks.get(sector_name, 0.0)
+            crowding_rank = sector_crowding_ranks.get(sector_name, 0.0)
+            composite_score = (
+                prosperity_rank * 0.40 + trend_rank * 0.30 + (1 - crowding_rank) * 0.30
+            )
+            for row in sector_rows:
+                row["sector_momentum_rank"] = round(
+                    sector_momentum_ranks.get(sector_name, 0.0), 4
+                )
+                row["sector_flow_rank"] = round(
+                    sector_flow_ranks.get(sector_name, 0.0), 4
+                )
+                row["sector_prosperity_rank"] = round(prosperity_rank, 4)
+                row["sector_trend_rank"] = round(trend_rank, 4)
+                row["sector_crowding_rank"] = round(crowding_rank, 4)
+                row["sector_composite_score"] = round(composite_score, 4)
+
+        factor_specs = {
+            "factor_value_score": (("pe_ttm", "asc"), ("pb", "asc"), ("dividend_yield_ttm", "desc")),
+            "factor_growth_score": (("revenue_yoy", "desc"), ("netprofit_yoy", "desc")),
+            "factor_quality_score": (("roe", "desc"), ("roic", "desc"), ("gross_margin", "desc")),
+            "factor_momentum_score": (("momentum_60_5", "desc"), ("relative_strength", "desc")),
+            "factor_sentiment_score": (("turnover_rate", "desc"), ("volume_ratio_5d", "desc")),
+        }
+        for output_field, specs in factor_specs.items():
+            maps = [_available_percentile_map(factors, field, direction) for field, direction in specs]
+            for row in factors:
+                values = [mapping.get(row["ts_code"]) for mapping in maps]
+                available = [value for value in values if value is not None]
+                row[output_field] = round(statistics.fmean(available), 4) if available else None
+
+        return_rank_map = _available_percentile_map(factors, "return_20d", "desc")
+        factor_weights = {}
+        for output_field in factor_specs:
+            pairs = [
+                (row.get(output_field), return_rank_map.get(row["ts_code"]))
+                for row in factors
+                if row.get(output_field) is not None and return_rank_map.get(row["ts_code"]) is not None
+            ]
+            correlation = _pearson([pair[0] for pair in pairs], [pair[1] for pair in pairs])
+            factor_weights[output_field] = max(0.05, correlation)
+        factor_weight_total = sum(factor_weights.values()) or 1
+        for row in factors:
+            weighted = [
+                (row.get(field), weight)
+                for field, weight in factor_weights.items()
+                if row.get(field) is not None
+            ]
+            row["multi_factor_composite"] = round(
+                sum(value * weight for value, weight in weighted)
+                / (sum(weight for _, weight in weighted) or factor_weight_total),
+                4,
+            ) if weighted else None
+
+        size_ranks = _available_percentile_map(factors, "total_mv_billion", "desc")
+        large_rows = [row for row in factors if (size_ranks.get(row["ts_code"]) or 0) >= 0.70]
+        small_rows = [
+            row for row in factors
+            if size_ranks.get(row["ts_code"]) is not None
+            and size_ranks[row["ts_code"]] <= 0.30
+        ]
+        large_return = statistics.fmean(row["return_20d"] for row in large_rows) if large_rows else 0
+        small_return = statistics.fmean(row["return_20d"] for row in small_rows) if small_rows else 0
+        prefer_large = large_return >= small_return
+        growth_rows = [row for row in factors if (row.get("factor_growth_score") or 0) >= 0.70]
+        value_rows = [row for row in factors if (row.get("factor_value_score") or 0) >= 0.70]
+        growth_return = statistics.fmean(row["return_20d"] for row in growth_rows) if growth_rows else 0
+        value_return = statistics.fmean(row["return_20d"] for row in value_rows) if value_rows else 0
+        prefer_growth = growth_return >= value_return
+        for row in factors:
+            size_rank = size_ranks.get(row["ts_code"])
+            row["style_size_fit"] = round(
+                size_rank if prefer_large else 1 - size_rank, 4
+            ) if size_rank is not None else None
+            style_factor = "factor_growth_score" if prefer_growth else "factor_value_score"
+            row["style_growth_fit"] = row.get(style_factor)
+            style_values = [
+                value for value in (row.get("style_size_fit"), row.get("style_growth_fit"))
+                if value is not None
+            ]
+            row["style_fit_score"] = round(statistics.fmean(style_values), 4) if style_values else None
+        momentum_ranks = _percentile_map(factors, "momentum_60_5", "desc")
+        return_ranks = _percentile_map(factors, "return_5d", "desc")
+        market_height = max((int(row.get("limit_streak") or 0) for row in factors), default=0)
+        prior_market_height = max((int(row.get("prior_limit_streak") or 0) for row in factors), default=0)
+        for row in factors:
+            row["momentum_60_5_rank"] = round(momentum_ranks.get(row["ts_code"], 0.0), 4)
+            row["return_5d_rank"] = round(return_ranks.get(row["ts_code"], 0.0), 4)
+            is_height = market_height >= 2 and int(row.get("limit_streak") or 0) == market_height
+            row["is_market_height"] = int(is_height)
+            row["new_space_board"] = int(
+                is_height
+                and not (
+                    prior_market_height >= 2
+                    and int(row.get("prior_limit_streak") or 0) == prior_market_height
+                )
+            )
+        return factors, actual_date

app/backend/features/screener/formula.py

@@ -0,0 +1,146 @@
+from __future__ import annotations
+
+import copy
+from typing import Any
+
+from backend.features.screener.catalog import (
+    ALLOWED_OPERATORS,
+    BUILTIN_STRATEGIES,
+    FACTOR_FIELDS,
+    REGIMES,
+)
+from backend.features.screener.indicators import _matches, _percentile_map, _risk_flags
+
+
+class FormulaEvaluator:
+    def validate_formula(self, formula: dict[str, Any]) -> dict[str, Any]:
+        if not isinstance(formula, dict):
+            raise ValueError("选股公式必须是 JSON 对象。")
+        result = copy.deepcopy(formula)
+        universe = result.setdefault("universe", {})
+        universe["exclude_st"] = bool(universe.get("exclude_st", True))
+        universe["listed_days_min"] = max(0, min(5000, int(universe.get("listed_days_min", 120))))
+        filters = result.setdefault("filters", [])
+        if not isinstance(filters, list) or len(filters) > 20:
+            raise ValueError("筛选条件必须是列表，且不能超过 20 条。")
+        for condition in filters:
+            field = condition.get("field")
+            operator = condition.get("op")
+            if field not in FACTOR_FIELDS:
+                raise ValueError(f"不支持的选股因子：{field}")
+            if operator not in ALLOWED_OPERATORS:
+                raise ValueError(f"不支持的运算符：{operator}")
+            if "value" not in condition:
+                raise ValueError(f"因子 {field} 缺少比较值。")
+        scores = result.setdefault("score", [])
+        if not isinstance(scores, list) or not scores or len(scores) > 12:
+            raise ValueError("评分因子应为 1 至 12 条。")
+        for item in scores:
+            if item.get("field") not in FACTOR_FIELDS:
+                raise ValueError(f"不支持的评分因子：{item.get('field')}")
+            item["weight"] = float(item.get("weight", 0))
+            if item["weight"] <= 0 or item["weight"] > 1:
+                raise ValueError("评分权重必须大于 0 且不超过 1。")
+            if item.get("direction", "desc") not in {"asc", "desc"}:
+                raise ValueError("评分方向只能是 asc 或 desc。")
+            item["direction"] = item.get("direction", "desc")
+        result["limit"] = max(1, min(50, int(result.get("limit", 15))))
+        result["min_score"] = max(0, min(1, float(result.get("min_score", 0))))
+        return result
+
+    def apply_formula(
+        self, rows: list[dict[str, Any]], formula: dict[str, Any], regime: str
+    ) -> list[dict[str, Any]]:
+        universe = formula["universe"]
+        eligible = []
+        score_fields = [item["field"] for item in formula["score"]]
+        for row in rows:
+            name = str(row.get("name") or "")
+            if universe.get("exclude_st") and ("ST" in name.upper() or "退" in name):
+                continue
+            if row.get("listed_days", 0) < universe.get("listed_days_min", 0):
+                continue
+            if any(row.get(field) is None for field in score_fields):
+                continue
+            if all(_matches(row.get(item["field"]), item["op"], item["value"]) for item in formula["filters"]):
+                eligible.append(row)
+        if not eligible:
+            return []
+
+        percentiles = {
+            item["field"]: _percentile_map(eligible, item["field"], item["direction"])
+            for item in formula["score"]
+        }
+        weight_total = sum(item["weight"] for item in formula["score"])
+        results = []
+        for row in eligible:
+            contributions = []
+            score = 0.0
+            for item in formula["score"]:
+                percentile = percentiles[item["field"]].get(row["ts_code"], 0.5)
+                points = percentile * item["weight"] / weight_total
+                score += points
+                contributions.append(
+                    {
+                        "field": item["field"],
+                        "label": FACTOR_FIELDS[item["field"]],
+                        "value": row.get(item["field"], 0),
+                        "points": round(points * 100, 1),
+                    }
+                )
+            if score < formula["min_score"]:
+                continue
+            contributions.sort(key=lambda item: item["points"], reverse=True)
+            item = dict(row)
+            item["score"] = round(score, 4)
+            item["score_display"] = round(score * 100, 1)
+            item["contributions"] = contributions
+            item["reason"] = "、".join(entry["label"] for entry in contributions[:3])
+            include_regime_risk = formula.get("meta", {}).get("library") != "curated"
+            item["risk_flags"] = _risk_flags(row, regime, include_regime_risk)
+            results.append(item)
+        results.sort(key=lambda item: item["score"], reverse=True)
+        return results[: formula["limit"]]
+
+
+def compile_local_strategy(prompt: str, regime: str) -> dict[str, Any]:
+    base = next((item for item in BUILTIN_STRATEGIES if regime in item["regimes"]), BUILTIN_STRATEGIES[1])
+    formula = copy.deepcopy(base["formula"])
+    description = prompt.strip() or base["description"]
+    lowered = description.lower()
+    if "低吸" in description:
+        formula["filters"] = [item for item in formula["filters"] if item["field"] != "pct_chg"]
+        formula["filters"].append({"field": "pct_chg", "op": "between", "value": [-3, 3]})
+    if "放量" in description:
+        formula["filters"].append({"field": "volume_ratio_5d", "op": ">=", "value": 1.2})
+    if "强势" in description or "突破" in description:
+        formula["filters"].append({"field": "return_5d", "op": ">=", "value": 5})
+    if "低波" in description or "稳健" in description:
+        formula["score"].append({"field": "volatility_10d", "weight": 0.18, "direction": "asc"})
+    if "资金" in description or "主力" in description:
+        formula["score"].append({"field": "net_flow_million", "weight": 0.18, "direction": "desc"})
+    if "小市值" in description or "小盘" in description:
+        formula["score"].append({"field": "circ_mv_billion", "weight": 0.15, "direction": "asc"})
+    if "竞价" in description:
+        formula["filters"].extend(
+            [
+                {"field": "auction_change", "op": "between", "value": [0.5, 8]},
+                {"field": "auction_amount_million", "op": ">=", "value": 2},
+            ]
+        )
+        formula["score"].extend(
+            [
+                {"field": "auction_volume_ratio", "weight": 0.20, "direction": "desc"},
+                {"field": "auction_amount_million", "weight": 0.18, "direction": "desc"},
+            ]
+        )
+    if "少量" in description or "精选" in description:
+        formula["limit"] = min(formula["limit"], 8)
+    formula["score"] = formula["score"][:12]
+    return {
+        "name": f"{REGIMES.get(regime, regime)}自定义策略",
+        "description": description,
+        "regimes": [regime],
+        "formula": formula,
+        "compiler": "local_template",
+    }

app/backend/features/screener/indicators.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import math
+import statistics
+from datetime import datetime
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+
+
+def _optional_number(value: Any) -> float | None:
+    if value in (None, ""):
+        return None
+    try:
+        result = float(value)
+    except (TypeError, ValueError):
+        return None
+    return result if math.isfinite(result) else None
+
+
+def _rounded_optional(value: Any, digits: int = 2) -> float | None:
+    parsed = _optional_number(value)
+    return round(parsed, digits) if parsed is not None else None
+
+
+def _limit_threshold(code: str, name: str) -> float:
+    if code.startswith(("4", "8")):
+        return 29.0
+    if code.startswith(("30", "68")):
+        return 19.0
+    return 9.5
+
+
+def _ending_streak(flags: list[bool], end_index: int | None = None) -> int:
+    if not flags:
+        return 0
+    index = len(flags) - 1 if end_index is None else min(end_index, len(flags) - 1)
+    streak = 0
+    while index >= 0 and flags[index]:
+        streak += 1
+        index -= 1
+    return streak
+
+
+def _max_streak(flags: list[bool]) -> int:
+    best = current = 0
+    for value in flags:
+        current = current + 1 if value else 0
+        best = max(best, current)
+    return best
+
+
+def _rsi(values: list[float], period: int = 6) -> float:
+    if len(values) <= period:
+        return 50.0
+    changes = [values[index] - values[index - 1] for index in range(len(values) - period, len(values))]
+    gains = sum(max(change, 0.0) for change in changes) / period
+    losses = sum(max(-change, 0.0) for change in changes) / period
+    if losses == 0:
+        return 100.0 if gains > 0 else 50.0
+    return 100 - 100 / (1 + gains / losses)
+
+
+def _ema(values: list[float], period: int) -> list[float]:
+    if not values:
+        return []
+    alpha = 2 / (period + 1)
+    result = [values[0]]
+    for value in values[1:]:
+        result.append(value * alpha + result[-1] * (1 - alpha))
+    return result
+
+
+def _macd_series(values: list[float]) -> tuple[list[float], list[float]]:
+    fast = _ema(values, 12)
+    slow = _ema(values, 26)
+    dif = [left - right for left, right in zip(fast, slow)]
+    return dif, _ema(dif, 9)
+
+
+def _macd_last(values: list[float]) -> tuple[float, float]:
+    dif, dea = _macd_series(values)
+    return (dif[-1], dea[-1]) if dif and dea else (0.0, 0.0)
+
+
+def _weekly_series(rows: list[dict[str, Any]]) -> tuple[list[float], list[float]]:
+    weeks: dict[str, tuple[float, float]] = {}
+    for row in rows:
+        trade_date = str(row.get("trade_date") or "")
+        try:
+            key = datetime.strptime(trade_date, "%Y%m%d").strftime("%G-%V")
+        except ValueError:
+            continue
+        close = _number(row.get("close"))
+        amount = _number(row.get("amount"))
+        previous = weeks.get(key, (close, 0.0))
+        weeks[key] = (close, previous[1] + amount)
+    ordered = list(weeks.values())
+    return [item[0] for item in ordered], [item[1] for item in ordered]
+
+
+def _broken_reversal_metrics(
+    rows: list[dict[str, Any]], flags: list[bool], code: str, name: str,
+) -> dict[str, Any]:
+    result = {"signal": 0, "days": 0, "recovered": 0, "volume_ratio": 0.0}
+    if not rows or not flags[-1]:
+        return result
+    current_close = _number(rows[-1].get("close"))
+    current_volume = _number(rows[-1].get("vol"))
+    for days in range(1, 4):
+        index = len(rows) - 1 - days
+        if index <= 0 or flags[index] or _ending_streak(flags, index - 1) < 2:
+            continue
+        broken_high = _number(rows[index].get("high"))
+        broken_volume = _number(rows[index].get("vol"))
+        recovered = int(current_close >= broken_high > 0)
+        volume_ratio = current_volume / broken_volume if broken_volume else 0.0
+        return {
+            "signal": int(recovered and volume_ratio >= 1),
+            "days": days,
+            "recovered": recovered,
+            "volume_ratio": round(volume_ratio, 3),
+        }
+    return result
+
+
+def _is_limit_bar(rows: list[dict[str, Any]], index: int, code: str, name: str) -> bool:
+    if index < 0 or index >= len(rows):
+        return False
+    return _number(rows[index].get("pct_chg")) >= _limit_threshold(code, name)
+
+
+def _touched_limit_bar(rows: list[dict[str, Any]], index: int, code: str, name: str) -> bool:
+    if index <= 0 or index >= len(rows):
+        return False
+    previous_close = _number(rows[index - 1].get("close"))
+    high = _number(rows[index].get("high"))
+    if previous_close <= 0 or high <= 0:
+        return False
+    touched_change = (high / previous_close - 1) * 100
+    return touched_change >= _limit_threshold(code, name)
+
+
+def _matches(actual: Any, operator: str, expected: Any) -> bool:
+    if actual is None:
+        return False
+    try:
+        if operator == "between":
+            return float(expected[0]) <= float(actual) <= float(expected[1])
+        if operator == "in":
+            return actual in expected
+        if operator == ">":
+            return float(actual) > float(expected)
+        if operator == ">=":
+            return float(actual) >= float(expected)
+        if operator == "<":
+            return float(actual) < float(expected)
+        if operator == "<=":
+            return float(actual) <= float(expected)
+        if operator == "==":
+            return actual == expected or float(actual) == float(expected)
+        if operator == "!=":
+            return actual != expected
+    except (TypeError, ValueError, IndexError):
+        return False
+    return False
+
+
+def _percentile_map(rows: list[dict[str, Any]], field: str, direction: str) -> dict[str, float]:
+    ordered = sorted(rows, key=lambda item: _number(item.get(field)))
+    denominator = max(1, len(ordered) - 1)
+    result = {}
+    for index, row in enumerate(ordered):
+        percentile = index / denominator
+        result[row["ts_code"]] = 1 - percentile if direction == "asc" else percentile
+    return result
+
+
+def _available_percentile_map(
+    rows: list[dict[str, Any]], field: str, direction: str,
+) -> dict[str, float | None]:
+    available = [row for row in rows if row.get(field) is not None]
+    result: dict[str, float | None] = {
+        str(row.get("ts_code") or ""): None for row in rows
+    }
+    if not available:
+        return result
+    ordered = sorted(available, key=lambda item: _number(item.get(field)))
+    denominator = max(1, len(ordered) - 1)
+    for index, row in enumerate(ordered):
+        percentile = 0.5 if len(ordered) == 1 else index / denominator
+        result[str(row.get("ts_code") or "")] = (
+            1 - percentile if direction == "asc" else percentile
+        )
+    return result
+
+
+def _pearson(first: list[float], second: list[float]) -> float:
+    if len(first) != len(second) or len(first) < 20:
+        return 0.0
+    first_mean = statistics.fmean(first)
+    second_mean = statistics.fmean(second)
+    numerator = sum(
+        (left - first_mean) * (right - second_mean)
+        for left, right in zip(first, second)
+    )
+    left_sum = sum((value - first_mean) ** 2 for value in first)
+    right_sum = sum((value - second_mean) ** 2 for value in second)
+    denominator = math.sqrt(left_sum * right_sum)
+    return numerator / denominator if denominator else 0.0
+
+
+def _risk_flags(
+    row: dict[str, Any], regime: str, include_regime_risk: bool = True
+) -> list[str]:
+    flags = []
+    if row.get("pct_chg", 0) >= 9.5:
+        flags.append("当日接近涨停，次日存在高开与无法成交风险")
+    if row.get("return_10d", 0) >= 25:
+        flags.append("短期累计涨幅较高")
+    if row.get("volatility_10d", 0) >= 7:
+        flags.append("波动率偏高")
+    if row.get("amount_billion", 0) < 1:
+        flags.append("成交承载力偏弱")
+    if include_regime_risk and regime == "retreat":
+        flags.append("市场处于退潮阶段，策略可能选择空仓")
+    return flags
+
+
+def _regime_reason(regime: str) -> str:
+    return {
+        "ice": "情绪和赚钱效应处于低位，重点观察率先抗跌与转折信号。",
+        "repair": "核心指标从低位改善，适合观察率先修复且有板块共振的方向。",
+        "fermentation": "赚钱效应扩散，主线和梯队持续增强。",
+        "climax": "情绪处于高位，后排跟风与兑现风险同时上升。",
+        "divergence": "指数或核心仍强，但广度、封板质量开始分化。",
+        "retreat": "情绪指标继续走弱，应提高筛选门槛并接受无候选结果。",
+    }.get(regime, "市场阶段待确认。")

app/backend/features/screener/publication.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import Any
+
+
+def resolve_published_batch(
+    markers: list[dict[str, Any]],
+    requested_date: str,
+    legacy_date: str = "",
+) -> tuple[dict[str, Any] | None, dict[str, Any], dict[str, Any] | None]:
+    requested_marker = next(
+        (
+            item for item in markers
+            if str(item.get("trade_date") or "") == requested_date
+        ),
+        None,
+    )
+    published = next(
+        (item for item in markers if item.get("status") == "complete"),
+        None,
+    )
+    if published is None and legacy_date:
+        published = {
+            "trade_date": legacy_date,
+            "status": "complete",
+            "legacy_inferred": True,
+            "completed": [],
+            "skipped": [],
+            "failed": [],
+        }
+
+    request_status = dict(requested_marker or {})
+    request_status.setdefault("trade_date", requested_date)
+    request_status.setdefault("status", "pending")
+    descriptor = _published_descriptor(published, requested_date, request_status)
+    if descriptor and descriptor["is_fallback"]:
+        request_status["retaining_trade_date"] = descriptor["trade_date"]
+    return published, request_status, descriptor
+
+
+def _published_descriptor(
+    marker: dict[str, Any] | None,
+    requested_date: str,
+    request_status: dict[str, Any],
+) -> dict[str, Any] | None:
+    if marker is None:
+        return None
+    trade_date = str(marker.get("trade_date") or "")
+    is_fallback = trade_date != requested_date
+    status = str(request_status.get("status") or "pending")
+    notice = ""
+    if is_fallback:
+        if status == "running":
+            notice = "所选日期候选正在生成，当前保留上一成功批次"
+        elif status in {"failed", "partial"}:
+            notice = "所选日期候选未完整发布，当前保留上一成功批次"
+        else:
+            notice = "所选日期候选尚未发布，当前展示最近成功批次"
+    return {
+        "trade_date": trade_date,
+        "status": "complete",
+        "started_at": marker.get("started_at") or "",
+        "finished_at": marker.get("finished_at") or marker.get("updated_at") or "",
+        "library_version": int(marker.get("library_version") or 0),
+        "completed_count": len(marker.get("completed") or []),
+        "skipped_count": len(marker.get("skipped") or []),
+        "legacy_inferred": bool(marker.get("legacy_inferred")),
+        "is_fallback": is_fallback,
+        "notice": notice,
+    }

app/backend/features/screener/regime.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Any
+
+from backend.data.numbers import finite_number as _number
+from backend.features.screener.catalog import REGIMES
+from backend.features.screener.indicators import _regime_reason
+from backend.features.sentiment.engine import build_sentiment_history, latest_contiguous_history
+from database import ReviewDatabase
+
+
+class RegimeDetector:
+    def __init__(self, database: ReviewDatabase) -> None:
+        self.database = database
+
+    def detect_regime(self, trade_date: str) -> dict[str, Any]:
+        series = latest_contiguous_history(
+            build_sentiment_history(self.database.list_snapshot_payloads(trade_date, 260))
+        )
+        if not series:
+            return {
+                "id": "repair", "label": REGIMES["repair"], "confidence": 25,
+                "reason": "复盘快照不足，暂按中性修复处理。", "evidence": [], "history": [],
+            }
+        current = series[-1]
+        previous = series[-2] if len(series) > 1 else current
+        score = _number(current.get("score"))
+        previous_score = _number(previous.get("score"))
+        delta = score - previous_score
+        seal_rate = _number(current.get("seal_rate"))
+        limit_up = _number(current.get("limit_up_count"))
+        broken = _number(current.get("broken_count"))
+        regime = next(
+            (key for key, label in REGIMES.items() if label == current.get("phase")),
+            "divergence",
+        )
+        confidence = min(92, 45 + len(series[-8:]) * 5 + min(abs(delta), 12))
+        evidence = [
+            f"情绪温度 {score:.0f}，较前一交易日 {delta:+.0f}，{current.get('direction') or '持平'}",
+            f"封板率 {seal_rate:.1f}%",
+            f"涨停 {limit_up:.0f} 家，炸板 {broken:.0f} 家",
+        ]
+        return {
+            "id": regime,
+            "label": REGIMES[regime],
+            "confidence": round(confidence),
+            "reason": _regime_reason(regime),
+            "evidence": evidence,
+            "history": [
+                {"trade_date": item["trade_date"], "score": _number(item.get("score"))}
+                for item in series[-8:]
+            ],
+        }

app/backend/features/screener/repository.py

@@ -0,0 +1,905 @@
+from __future__ import annotations
+
+import json
+import sqlite3
+from datetime import datetime
+from typing import Any
+
+from backend.features.sentiment.engine import build_sentiment_history
+
+
+def _optional_float(value: Any) -> float | None:
+    if value in (None, ""):
+        return None
+    try:
+        return float(value)
+    except (TypeError, ValueError):
+        return None
+
+
+class ScreenerRepositoryMixin:
+    def upsert_benchmark_bars(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("trade_date") or ""), str(row.get("ts_code") or ""),
+                float(row.get("close") or 0), float(row.get("pct_chg") or 0),
+            )
+            for row in rows if row.get("trade_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO benchmark_bars (trade_date, ts_code, close, pct_chg)
+                VALUES (?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    close=excluded.close, pct_chg=excluded.pct_chg
+                """,
+                values,
+            )
+        return len(values)
+
+    def upsert_daily_indicators(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("trade_date") or ""), row.get("ts_code", ""),
+                float(row.get("turnover_rate") or 0), float(row.get("volume_ratio") or 0),
+                float(row.get("total_mv") or 0), float(row.get("circ_mv") or 0),
+                _optional_float(row.get("pe_ttm")), _optional_float(row.get("pb")),
+                _optional_float(row.get("ps_ttm")), _optional_float(row.get("dv_ttm")),
+            )
+            for row in rows if row.get("trade_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO daily_indicators
+                    (trade_date, ts_code, turnover_rate, volume_ratio, total_mv, circ_mv,
+                     pe_ttm, pb, ps_ttm, dv_ttm)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    turnover_rate=excluded.turnover_rate, volume_ratio=excluded.volume_ratio,
+                    total_mv=excluded.total_mv, circ_mv=excluded.circ_mv,
+                    pe_ttm=excluded.pe_ttm, pb=excluded.pb,
+                    ps_ttm=excluded.ps_ttm, dv_ttm=excluded.dv_ttm
+                """,
+                values,
+            )
+        return len(values)
+
+    def upsert_fundamental_indicators(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("end_date") or ""), str(row.get("ann_date") or ""),
+                str(row.get("ts_code") or ""), _optional_float(row.get("roe")),
+                _optional_float(row.get("roa")), _optional_float(row.get("roic")),
+                _optional_float(row.get("grossprofit_margin")),
+                _optional_float(row.get("netprofit_yoy")), _optional_float(row.get("or_yoy")),
+                _optional_float(row.get("ocf_to_opincome")),
+            )
+            for row in rows
+            if row.get("end_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO fundamental_indicators
+                    (end_date, ann_date, ts_code, roe, roa, roic, grossprofit_margin,
+                     netprofit_yoy, or_yoy, ocf_to_opincome)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(end_date, ts_code) DO UPDATE SET
+                    ann_date=excluded.ann_date, roe=excluded.roe, roa=excluded.roa,
+                    roic=excluded.roic, grossprofit_margin=excluded.grossprofit_margin,
+                    netprofit_yoy=excluded.netprofit_yoy, or_yoy=excluded.or_yoy,
+                    ocf_to_opincome=excluded.ocf_to_opincome
+                """,
+                values,
+            )
+        return len(values)
+
+    def upsert_moneyflow(self, rows: list[dict[str, Any]]) -> int:
+        values = []
+        for row in rows:
+            if not row.get("trade_date") or not row.get("ts_code"):
+                continue
+            large_net = (
+                float(row.get("buy_lg_amount") or 0) + float(row.get("buy_elg_amount") or 0)
+                - float(row.get("sell_lg_amount") or 0) - float(row.get("sell_elg_amount") or 0)
+            )
+            medium_net = float(row.get("buy_md_amount") or 0) - float(row.get("sell_md_amount") or 0)
+            small_net = float(row.get("buy_sm_amount") or 0) - float(row.get("sell_sm_amount") or 0)
+            values.append((
+                str(row["trade_date"]), row["ts_code"], float(row.get("net_mf_amount") or 0),
+                large_net, medium_net, small_net,
+            ))
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO moneyflow_daily
+                    (trade_date, ts_code, net_mf_amount, large_net_amount, medium_net_amount, small_net_amount)
+                VALUES (?, ?, ?, ?, ?, ?)
+                ON CONFLICT(trade_date, ts_code) DO UPDATE SET
+                    net_mf_amount=excluded.net_mf_amount, large_net_amount=excluded.large_net_amount,
+                    medium_net_amount=excluded.medium_net_amount, small_net_amount=excluded.small_net_amount
+                """,
+                values,
+            )
+        return len(values)
+
+    def upsert_earnings_events(self, rows: list[dict[str, Any]]) -> int:
+        values = [
+            (
+                str(row.get("end_date") or ""),
+                str(row.get("ann_date") or ""),
+                str(row.get("ts_code") or ""),
+                _optional_float(row.get("forecast_profit")),
+                _optional_float(row.get("actual_profit")),
+                _optional_float(row.get("surprise_pct")),
+                _optional_float(row.get("revenue_yoy")),
+                _optional_float(row.get("netprofit_yoy")),
+                str(row.get("source") or ""),
+            )
+            for row in rows
+            if row.get("end_date") and row.get("ann_date") and row.get("ts_code")
+        ]
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO earnings_events
+                    (end_date, ann_date, ts_code, forecast_profit, actual_profit,
+                     surprise_pct, revenue_yoy, netprofit_yoy, source)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(end_date, ann_date, ts_code) DO UPDATE SET
+                    forecast_profit=excluded.forecast_profit,
+                    actual_profit=excluded.actual_profit,
+                    surprise_pct=excluded.surprise_pct,
+                    revenue_yoy=excluded.revenue_yoy,
+                    netprofit_yoy=excluded.netprofit_yoy,
+                    source=excluded.source
+                """,
+                values,
+            )
+        return len(values)
+
+    def daily_indicator_dates(self, end_date: str = "", limit: int = 400) -> list[str]:
+        where = "WHERE trade_date <= ?" if end_date else ""
+        parameters: tuple[Any, ...] = (end_date, limit) if end_date else (limit,)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"SELECT DISTINCT trade_date FROM daily_indicators {where} "
+                "ORDER BY trade_date DESC LIMIT ?",
+                parameters,
+            ).fetchall()
+        return [row["trade_date"] for row in reversed(rows)]
+
+    def fundamental_periods(self) -> list[str]:
+        with self.connect() as connection:
+            rows = connection.execute(
+                "SELECT DISTINCT end_date FROM fundamental_indicators ORDER BY end_date"
+            ).fetchall()
+        return [str(row["end_date"]) for row in rows]
+
+    def factor_dates(self, end_date: str = "", limit: int = 80) -> list[str]:
+        where = "WHERE trade_date <= ?" if end_date else ""
+        parameters: tuple[Any, ...] = (end_date, limit) if end_date else (limit,)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"SELECT DISTINCT trade_date FROM daily_bars {where} ORDER BY trade_date DESC LIMIT ?",
+                parameters,
+            ).fetchall()
+        return [row["trade_date"] for row in reversed(rows)]
+
+    def factor_health_summary(self, end_date: str) -> dict[str, Any]:
+        dividend_start = f"{max(0, int(end_date[:4] or 0) - 5)}0101"
+        with self.connect() as connection:
+            market = connection.execute(
+                "SELECT EXISTS(SELECT 1 FROM daily_bars WHERE trade_date <= ? LIMIT 1)",
+                (end_date,),
+            ).fetchone()[0]
+            auction = connection.execute(
+                "SELECT EXISTS(SELECT 1 FROM auction_factors WHERE trade_date <= ? LIMIT 1)",
+                (end_date,),
+            ).fetchone()[0]
+            benchmark_rows = connection.execute(
+                "SELECT COUNT(*) FROM benchmark_bars WHERE ts_code = '000300.SH' AND trade_date <= ?",
+                (end_date,),
+            ).fetchone()[0]
+            indicator_date = connection.execute(
+                "SELECT MAX(trade_date) FROM daily_indicators WHERE trade_date <= ?",
+                (end_date,),
+            ).fetchone()[0]
+            if indicator_date:
+                valuation_rows, valuation_available = connection.execute(
+                    """
+                    SELECT COUNT(*), COALESCE(MAX(pe_ttm IS NOT NULL), 0)
+                    FROM daily_indicators WHERE trade_date = ?
+                    """,
+                    (indicator_date,),
+                ).fetchone()
+            else:
+                valuation_rows, valuation_available = 0, 0
+            dividend_years = connection.execute(
+                """
+                SELECT COUNT(DISTINCT substr(trade_date, 1, 4))
+                FROM daily_indicators
+                WHERE trade_date <= ? AND trade_date >= ?
+                """,
+                (end_date, dividend_start),
+            ).fetchone()[0]
+            fundamental_rows = connection.execute(
+                """
+                SELECT COUNT(*) FROM fundamental_indicators fi
+                INNER JOIN (
+                    SELECT ts_code, MAX(ann_date || ':' || end_date) AS latest_key
+                    FROM fundamental_indicators
+                    WHERE ann_date = '' OR ann_date <= ?
+                    GROUP BY ts_code
+                ) latest
+                ON latest.ts_code = fi.ts_code
+                   AND latest.latest_key = (fi.ann_date || ':' || fi.end_date)
+                """,
+                (end_date,),
+            ).fetchone()[0]
+            moneyflow_dates = connection.execute(
+                """
+                SELECT COUNT(DISTINCT trade_date)
+                FROM moneyflow_daily
+                WHERE trade_date IN (
+                    SELECT DISTINCT trade_date
+                    FROM daily_bars
+                    WHERE trade_date <= ?
+                    ORDER BY trade_date DESC
+                    LIMIT 5
+                )
+                """,
+                (end_date,),
+            ).fetchone()[0]
+            earnings_rows = connection.execute(
+                """
+                SELECT COUNT(*) FROM earnings_events
+                WHERE ann_date <= ? AND ann_date >= replace(date(?, '-45 day'), '-', '')
+                """,
+                (end_date, f"{end_date[:4]}-{end_date[4:6]}-{end_date[6:8]}"),
+            ).fetchone()[0]
+            popularity_rows = connection.execute(
+                "SELECT COUNT(*) FROM popularity_factors WHERE trade_date = ?",
+                (end_date,),
+            ).fetchone()[0]
+            institution_rows = connection.execute(
+                "SELECT COUNT(*) FROM lhb_institution_daily WHERE trade_date = ?",
+                (end_date,),
+            ).fetchone()[0]
+        return {
+            "market": bool(market),
+            "auction": bool(auction),
+            "benchmark": int(benchmark_rows or 0) >= 60,
+            "benchmark_rows": int(benchmark_rows or 0),
+            "valuation": bool(valuation_available),
+            "fundamental": int(fundamental_rows or 0) >= 100,
+            "dividend_history": int(dividend_years or 0) >= 4,
+            "valuation_rows": int(valuation_rows or 0),
+            "fundamental_rows": int(fundamental_rows or 0),
+            "dividend_years": int(dividend_years or 0),
+            "moneyflow_history": int(moneyflow_dates or 0) >= 5,
+            "moneyflow_dates": int(moneyflow_dates or 0),
+            "earnings_events": int(earnings_rows or 0) > 0,
+            "earnings_event_rows": int(earnings_rows or 0),
+            "popularity": int(popularity_rows or 0) > 0,
+            "popularity_rows": int(popularity_rows or 0),
+            "institutions": int(institution_rows or 0) > 0,
+            "institution_rows": int(institution_rows or 0),
+        }
+
+    def load_factor_data(self, end_date: str, limit_dates: int = 80) -> dict[str, Any]:
+        dates = self.factor_dates(end_date, limit_dates)
+        if not dates:
+            return {
+                "dates": [], "bars": [], "master": [], "indicators": [],
+                "indicator_history": [], "indicator_series": [], "fundamentals": [],
+                "moneyflow": [], "moneyflow_history": [], "auction": [],
+                "benchmarks": [], "fundamental_history": [],
+                "earnings_events": [], "popularity": [], "institutions": [],
+            }
+        placeholders = ",".join("?" for _ in dates)
+        with self.connect() as connection:
+            bars = connection.execute(
+                f"SELECT * FROM daily_bars WHERE trade_date IN ({placeholders}) ORDER BY trade_date, ts_code",
+                dates,
+            ).fetchall()
+            master = connection.execute("SELECT * FROM stock_master").fetchall()
+            indicators = connection.execute(
+                """
+                SELECT * FROM daily_indicators
+                WHERE trade_date = (
+                    SELECT MAX(trade_date) FROM daily_indicators WHERE trade_date <= ?
+                )
+                """,
+                (end_date,),
+            ).fetchall()
+            indicator_history = connection.execute(
+                """
+                SELECT di.* FROM daily_indicators di
+                INNER JOIN (
+                    SELECT ts_code, substr(trade_date, 1, 4) AS year_key,
+                           MAX(trade_date) AS max_date
+                    FROM daily_indicators
+                    WHERE trade_date <= ? AND trade_date >= ?
+                    GROUP BY ts_code, substr(trade_date, 1, 4)
+                ) latest
+                ON latest.ts_code = di.ts_code AND latest.max_date = di.trade_date
+                ORDER BY di.trade_date, di.ts_code
+                """,
+                (end_date, str(max(0, int(end_date[:4] or 0) - 5)) + "0101"),
+            ).fetchall()
+            indicator_series = connection.execute(
+                f"""
+                SELECT trade_date, ts_code, turnover_rate, volume_ratio,
+                       total_mv, circ_mv, pe_ttm, pb, ps_ttm, dv_ttm
+                FROM daily_indicators
+                WHERE trade_date IN ({placeholders})
+                ORDER BY trade_date, ts_code
+                """,
+                dates,
+            ).fetchall()
+            fundamentals = connection.execute(
+                """
+                SELECT fi.* FROM fundamental_indicators fi
+                INNER JOIN (
+                    SELECT ts_code, MAX(ann_date || ':' || end_date) AS latest_key
+                    FROM fundamental_indicators
+                    WHERE ann_date = '' OR ann_date <= ?
+                    GROUP BY ts_code
+                ) latest
+                ON latest.ts_code = fi.ts_code
+                   AND latest.latest_key = (fi.ann_date || ':' || fi.end_date)
+                """,
+                (end_date,),
+            ).fetchall()
+            fundamental_history = connection.execute(
+                """
+                SELECT * FROM fundamental_indicators
+                WHERE ann_date = '' OR ann_date <= ?
+                ORDER BY ann_date, end_date, ts_code
+                """,
+                (end_date,),
+            ).fetchall()
+            moneyflow = connection.execute(
+                """
+                SELECT * FROM moneyflow_daily
+                WHERE trade_date = (
+                    SELECT MAX(trade_date) FROM moneyflow_daily WHERE trade_date <= ?
+                )
+                """,
+                (end_date,),
+            ).fetchall()
+            flow_dates = dates[-min(5, len(dates)):]
+            flow_placeholders = ",".join("?" for _ in flow_dates)
+            moneyflow_history = connection.execute(
+                f"""
+                SELECT * FROM moneyflow_daily
+                WHERE trade_date IN ({flow_placeholders})
+                ORDER BY trade_date, ts_code
+                """,
+                flow_dates,
+            ).fetchall()
+            auction = connection.execute(
+                """
+                SELECT * FROM auction_factors
+                WHERE trade_date = (
+                    SELECT MAX(trade_date) FROM auction_factors WHERE trade_date <= ?
+                )
+                """,
+                (end_date,),
+            ).fetchall()
+            benchmarks = connection.execute(
+                f"""
+                SELECT * FROM benchmark_bars
+                WHERE ts_code = '000300.SH' AND trade_date IN ({placeholders})
+                ORDER BY trade_date
+                """,
+                dates,
+            ).fetchall()
+            earnings_events = connection.execute(
+                """
+                SELECT * FROM earnings_events
+                WHERE ann_date <= ?
+                ORDER BY ann_date, end_date, ts_code
+                """,
+                (end_date,),
+            ).fetchall()
+            popularity = connection.execute(
+                "SELECT * FROM popularity_factors WHERE trade_date = ? ORDER BY ts_code",
+                (end_date,),
+            ).fetchall()
+            institutions = connection.execute(
+                "SELECT * FROM lhb_institution_daily WHERE trade_date = ? ORDER BY ts_code",
+                (end_date,),
+            ).fetchall()
+        return {
+            "dates": dates,
+            "bars": [dict(row) for row in bars],
+            "master": [dict(row) for row in master],
+            "indicators": [dict(row) for row in indicators],
+            "indicator_history": [dict(row) for row in indicator_history],
+            "indicator_series": [dict(row) for row in indicator_series],
+            "fundamentals": [dict(row) for row in fundamentals],
+            "fundamental_history": [dict(row) for row in fundamental_history],
+            "moneyflow": [dict(row) for row in moneyflow],
+            "moneyflow_history": [dict(row) for row in moneyflow_history],
+            "auction": [dict(row) for row in auction],
+            "benchmarks": [dict(row) for row in benchmarks],
+            "earnings_events": [dict(row) for row in earnings_events],
+            "popularity": [dict(row) for row in popularity],
+            "institutions": [dict(row) for row in institutions],
+        }
+
+    def snapshot_summaries(self, end_date: str, limit: int = 10) -> list[dict[str, Any]]:
+        series = build_sentiment_history(self.list_snapshot_payloads(end_date, 260))
+        return [
+            {
+                "trade_date": row["trade_date"],
+                "sentiment_score": row["score"],
+                "seal_rate": row["seal_rate"],
+                "limit_up_count": row["limit_up_count"],
+                "limit_down_count": row["limit_down_count"],
+                "broken_count": row["broken_count"],
+                "up_count": row["up_count"],
+                "down_count": row["down_count"],
+                "amount_billion": row["amount_billion"],
+            }
+            for row in series[-limit:]
+        ]
+
+    def save_screener_strategy(
+        self, user_id: int | None, name: str, description: str, regimes: list[str], formula: dict[str, Any],
+        builtin: bool = False, strategy_id: int | None = None,
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        regimes_json = json.dumps(regimes, ensure_ascii=False)
+        formula_json = json.dumps(formula, ensure_ascii=False, separators=(",", ":"))
+        with self.connect() as connection:
+            if strategy_id:
+                if builtin:
+                    cursor = connection.execute(
+                        """
+                        UPDATE screener_strategies SET name=?, description=?, regimes=?, formula=?,
+                            builtin=1, user_id=NULL, updated_at=? WHERE id=? AND builtin=1
+                        """,
+                        (name, description, regimes_json, formula_json, now, strategy_id),
+                    )
+                else:
+                    cursor = connection.execute(
+                        """
+                        UPDATE screener_strategies SET name=?, description=?, regimes=?, formula=?,
+                            updated_at=? WHERE id=? AND builtin=0 AND user_id=?
+                        """,
+                        (name, description, regimes_json, formula_json, now, strategy_id, int(user_id or 0)),
+                    )
+                if cursor.rowcount == 0:
+                    raise ValueError("选股策略不存在。")
+                return strategy_id
+            cursor = connection.execute(
+                """
+                INSERT INTO screener_strategies
+                    (user_id, name, description, regimes, formula, builtin, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (None if builtin else int(user_id or 0), name, description, regimes_json, formula_json, int(builtin), now, now),
+            )
+            return int(cursor.lastrowid)
+
+    def list_screener_strategies(self, user_id: int | None = None) -> list[dict[str, Any]]:
+        with self.connect() as connection:
+            if user_id is None:
+                rows = connection.execute(
+                    "SELECT * FROM screener_strategies WHERE builtin = 1 ORDER BY updated_at DESC, id"
+                ).fetchall()
+            else:
+                rows = connection.execute(
+                    """
+                    SELECT * FROM screener_strategies
+                    WHERE builtin = 1 OR user_id = ?
+                    ORDER BY builtin DESC, updated_at DESC, id
+                    """,
+                    (int(user_id),),
+                ).fetchall()
+        result = []
+        for row in rows:
+            item = dict(row)
+            item["regimes"] = json.loads(item["regimes"])
+            item["formula"] = json.loads(item["formula"])
+            item["builtin"] = bool(item["builtin"])
+            result.append(item)
+        return result
+
+    def delete_screener_strategy(self, user_id: int, strategy_id: int) -> bool:
+        with self.connect() as connection:
+            row = connection.execute(
+                "SELECT builtin, user_id FROM screener_strategies WHERE id = ?",
+                (strategy_id,),
+            ).fetchone()
+            if not row:
+                raise ValueError("选股策略不存在。")
+            if bool(row["builtin"]):
+                raise ValueError("内置策略不能删除。")
+            if int(row["user_id"] or 0) != int(user_id):
+                raise ValueError("无权删除其他账号的策略。")
+            cursor = connection.execute(
+                "DELETE FROM screener_strategies WHERE id = ? AND builtin = 0 AND user_id = ?",
+                (strategy_id, int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def save_screener_run(
+        self, user_id: int, trade_date: str, regime: str, strategy_name: str,
+        formula: dict[str, Any], result: dict[str, Any], mode: str = "smart",
+    ) -> int:
+        normalized_mode = mode if mode in {"smart", "curated", "quant"} else "smart"
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        with self.connect() as connection:
+            cursor = connection.execute(
+                """
+                INSERT INTO screener_runs
+                    (user_id, trade_date, regime, mode, strategy_name, formula, result, created_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                """,
+                (None if int(user_id) == 0 else int(user_id), trade_date, regime,
+                 normalized_mode, strategy_name,
+                 json.dumps(formula, ensure_ascii=False, separators=(",", ":")),
+                 json.dumps(result, ensure_ascii=False, separators=(",", ":")), now),
+            )
+            return int(cursor.lastrowid)
+
+    @staticmethod
+    def _screener_run_payload(row: sqlite3.Row) -> dict[str, Any] | None:
+        try:
+            result = json.loads(row["result"])
+        except json.JSONDecodeError:
+            return None
+        result.setdefault("meta", {}).update(
+            {
+                "run_id": int(row["id"]),
+                "trade_date": str(row["trade_date"] or ""),
+                "regime": str(row["regime"] or ""),
+                "mode": str(row["mode"] or "smart"),
+                "strategy_name": str(row["strategy_name"] or ""),
+                "created_at": row["created_at"],
+            }
+        )
+        return result
+
+    def latest_screener_run(
+        self, user_id: int, trade_date: str, mode: str = "",
+    ) -> dict[str, Any] | None:
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: tuple[Any, ...] = () if int(user_id) == 0 else (int(user_id),)
+        parameters += (trade_date,)
+        mode_clause = ""
+        if mode in {"smart", "curated", "quant"}:
+            mode_clause = " AND mode = ?"
+            parameters += (mode,)
+        with self.connect() as connection:
+            row = connection.execute(
+                f"""
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM screener_runs
+                WHERE {owner_clause} AND trade_date <= ?{mode_clause}
+                ORDER BY id DESC LIMIT 1
+                """,
+                parameters,
+            ).fetchone()
+        return self._screener_run_payload(row) if row else None
+
+    def latest_screener_runs(self, user_id: int, trade_date: str) -> dict[str, dict[str, Any]]:
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: tuple[Any, ...] = () if int(user_id) == 0 else (int(user_id),)
+        parameters += (trade_date,)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT runs.id, runs.trade_date, runs.regime, runs.mode,
+                       runs.strategy_name, runs.result, runs.created_at
+                FROM screener_runs runs
+                INNER JOIN (
+                    SELECT mode, MAX(id) AS id
+                    FROM screener_runs
+                    WHERE {owner_clause} AND trade_date <= ?
+                    GROUP BY mode
+                ) latest ON latest.id = runs.id
+                """,
+                parameters,
+            ).fetchall()
+        results: dict[str, dict[str, Any]] = {}
+        for row in rows:
+            mode = str(row["mode"] or "smart")
+            payload = self._screener_run_payload(row)
+            if mode in {"smart", "curated", "quant"} and payload:
+                results[mode] = payload
+        return results
+
+    def latest_screener_context_runs(
+        self, user_id: int, trade_date: str, limit: int = 60,
+    ) -> list[dict[str, Any]]:
+        safe_limit = max(1, min(120, int(limit)))
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: tuple[Any, ...] = () if int(user_id) == 0 else (int(user_id),)
+        parameters += (trade_date, safe_limit)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                WITH ranked AS (
+                    SELECT id, trade_date, regime, mode, strategy_name, result, created_at,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY
+                                   mode,
+                                   CASE WHEN mode = 'smart' THEN regime ELSE '' END,
+                                   CASE WHEN mode IN ('smart', 'curated') THEN strategy_name ELSE '' END
+                               ORDER BY id DESC
+                           ) AS context_rank
+                    FROM screener_runs
+                    WHERE {owner_clause} AND trade_date <= ?
+                )
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM ranked
+                WHERE context_rank = 1
+                ORDER BY id DESC
+                LIMIT ?
+                """,
+                parameters,
+            ).fetchall()
+        return [
+            payload
+            for row in rows
+            if (payload := self._screener_run_payload(row)) is not None
+        ]
+
+    def screener_runs_for_date(
+        self, user_id: int, trade_date: str, limit: int = 80,
+    ) -> list[dict[str, Any]]:
+        safe_limit = max(1, min(160, int(limit)))
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: tuple[Any, ...] = () if int(user_id) == 0 else (int(user_id),)
+        parameters += (trade_date, safe_limit)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM screener_runs
+                WHERE {owner_clause} AND trade_date = ?
+                ORDER BY id DESC
+                LIMIT ?
+                """,
+                parameters,
+            ).fetchall()
+        result = []
+        seen: set[tuple[str, str, str]] = set()
+        for row in rows:
+            key = (
+                str(row["mode"] or "smart"),
+                str(row["regime"] or ""),
+                str(row["strategy_name"] or ""),
+            )
+            if key in seen:
+                continue
+            seen.add(key)
+            payload = self._screener_run_payload(row)
+            if payload is not None:
+                result.append(payload)
+        return result
+
+    def screener_runs_for_dates(
+        self, user_id: int, trade_dates: list[str], limit: int = 1200,
+    ) -> list[dict[str, Any]]:
+        normalized_dates = list(dict.fromkeys(str(item) for item in trade_dates if item))
+        if not normalized_dates:
+            return []
+        safe_limit = max(1, min(2400, int(limit)))
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: list[Any] = [] if int(user_id) == 0 else [int(user_id)]
+        placeholders = ",".join("?" for _ in normalized_dates)
+        parameters.extend(normalized_dates)
+        parameters.append(safe_limit)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                WITH ranked AS (
+                    SELECT id, trade_date, regime, mode, strategy_name, result, created_at,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY trade_date, mode, regime, strategy_name
+                               ORDER BY id DESC
+                           ) AS context_rank
+                    FROM screener_runs
+                    WHERE {owner_clause} AND trade_date IN ({placeholders})
+                )
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM ranked
+                WHERE context_rank = 1
+                ORDER BY trade_date DESC, id DESC
+                LIMIT ?
+                """,
+                parameters,
+            ).fetchall()
+        return [
+            payload
+            for row in rows
+            if (payload := self._screener_run_payload(row)) is not None
+        ]
+
+    def recent_screener_runs(
+        self, user_id: int, trade_date: str, mode: str, limit: int = 40,
+    ) -> list[dict[str, Any]]:
+        if int(user_id) == 0 or mode not in {"smart", "curated", "quant"}:
+            return []
+        safe_limit = max(1, min(160, int(limit)))
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                WITH ranked AS (
+                    SELECT id, trade_date, regime, mode, strategy_name, result, created_at,
+                           ROW_NUMBER() OVER (
+                               PARTITION BY trade_date, mode, regime, strategy_name
+                               ORDER BY id DESC
+                           ) AS context_rank
+                    FROM screener_runs
+                    WHERE user_id = ? AND trade_date <= ? AND mode = ?
+                )
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM ranked
+                WHERE context_rank = 1
+                ORDER BY trade_date DESC, id DESC
+                LIMIT ?
+                """,
+                (int(user_id), trade_date, mode, safe_limit),
+            ).fetchall()
+        return [
+            payload
+            for row in rows
+            if (payload := self._screener_run_payload(row)) is not None
+        ]
+
+    def list_screener_batch_markers(
+        self, end_date: str, limit: int = 30,
+    ) -> list[dict[str, Any]]:
+        safe_limit = max(1, min(120, int(limit)))
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT cache_key, payload, updated_at
+                FROM data_snapshots
+                WHERE kind = 'screener_auto_v1' AND cache_key <= ?
+                ORDER BY cache_key DESC
+                LIMIT ?
+                """,
+                (end_date, safe_limit),
+            ).fetchall()
+        result = []
+        for row in rows:
+            try:
+                payload = json.loads(row["payload"])
+            except json.JSONDecodeError:
+                continue
+            payload.setdefault("trade_date", str(row["cache_key"] or ""))
+            payload.setdefault("updated_at", str(row["updated_at"] or ""))
+            result.append(payload)
+        return result
+
+    def get_screener_run(self, user_id: int, run_id: int) -> dict[str, Any] | None:
+        owner_clause = "user_id IS NULL" if int(user_id) == 0 else "user_id = ?"
+        parameters: tuple[Any, ...] = (int(run_id),)
+        if int(user_id) != 0:
+            parameters += (int(user_id),)
+        with self.connect() as connection:
+            row = connection.execute(
+                f"""
+                SELECT id, trade_date, regime, mode, strategy_name, result, created_at
+                FROM screener_runs WHERE id = ? AND {owner_clause}
+                """,
+                parameters,
+            ).fetchone()
+        if not row:
+            return None
+        result = self._screener_run_payload(row)
+        if result is None:
+            return None
+        result.setdefault("meta", {}).update(
+            {
+                "run_id": int(row["id"]),
+                "trade_date": row["trade_date"],
+                "mode": str(row["mode"] or "smart"),
+                "created_at": row["created_at"],
+            }
+        )
+        result["strategy_name"] = row["strategy_name"]
+        result["regime"] = row["regime"]
+        return result
+
+    def save_strategy_tracks(
+        self,
+        user_id: int,
+        run_id: int,
+        selection_date: str,
+        strategy_name: str,
+        candidates: list[dict[str, Any]],
+    ) -> int:
+        now = datetime.now().astimezone().isoformat(timespec="seconds")
+        values = []
+        for item in candidates:
+            ts_code = str(item.get("ts_code") or "").strip()
+            code = str(item.get("code") or ts_code.split(".")[0]).strip()
+            entry_price = float(item.get("price") or 0)
+            if not ts_code or not code or entry_price <= 0:
+                continue
+            values.append(
+                (
+                    int(user_id), int(run_id), selection_date, strategy_name, ts_code, code,
+                    str(item.get("name") or "--"), str(item.get("sector") or "其他"),
+                    entry_price, now, now,
+                )
+            )
+        with self.connect() as connection:
+            connection.executemany(
+                """
+                INSERT INTO strategy_tracks
+                    (user_id, run_id, selection_date, strategy_name, ts_code, code,
+                     name, sector, entry_price, created_at, updated_at)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(user_id, run_id, ts_code) DO UPDATE SET
+                    name=excluded.name, sector=excluded.sector,
+                    entry_price=excluded.entry_price, updated_at=excluded.updated_at
+                """,
+                values,
+            )
+        return len(values)
+
+    def list_strategy_tracks(self, user_id: int, limit_batches: int = 12) -> list[dict[str, Any]]:
+        limit_batches = max(1, min(50, int(limit_batches)))
+        with self.connect() as connection:
+            rows = connection.execute(
+                """
+                SELECT * FROM strategy_tracks
+                WHERE user_id = ? AND run_id IN (
+                    SELECT run_id FROM strategy_tracks WHERE user_id = ?
+                    GROUP BY run_id ORDER BY run_id DESC LIMIT ?
+                )
+                ORDER BY run_id DESC, id
+                """,
+                (int(user_id), int(user_id), limit_batches),
+            ).fetchall()
+        return [dict(row) for row in rows]
+
+    def delete_strategy_track(self, user_id: int, track_id: int) -> bool:
+        with self.connect() as connection:
+            cursor = connection.execute(
+                "DELETE FROM strategy_tracks WHERE id = ? AND user_id = ?",
+                (int(track_id), int(user_id)),
+            )
+            return cursor.rowcount > 0
+
+    def load_tracking_bars(
+        self, targets: list[tuple[str, str]], limit: int = 5
+    ) -> dict[tuple[str, str], list[dict[str, Any]]]:
+        unique_targets = set(targets)
+        if not unique_targets:
+            return {}
+        codes = sorted({ts_code for ts_code, _ in unique_targets})
+        earliest_date = min(selection_date for _, selection_date in unique_targets)
+        placeholders = ",".join("?" for _ in codes)
+        with self.connect() as connection:
+            rows = connection.execute(
+                f"""
+                SELECT ts_code, trade_date, open, high, low, close FROM daily_bars
+                WHERE ts_code IN ({placeholders}) AND trade_date > ?
+                ORDER BY ts_code, trade_date
+                """,
+                [*codes, earliest_date],
+            ).fetchall()
+        by_code: dict[str, list[dict[str, Any]]] = {}
+        for row in rows:
+            item = dict(row)
+            by_code.setdefault(str(item["ts_code"]), []).append(item)
+        row_limit = max(1, min(20, int(limit)))
+        return {
+            (ts_code, selection_date): [
+                row for row in by_code.get(ts_code, []) if row["trade_date"] > selection_date
+            ][:row_limit]
+            for ts_code, selection_date in unique_targets
+        }