feat(web): 字段库页 + 界面单位换算 + 因子目录参数化 + 选股策略条件表单

字段库与单位：
- `/fields`：字段库管理页（中文名/说明可改、可停用；kind 是引擎事实不可改）；
  单位只在字段自己的阶梯里选（总市值 = 万元/亿元），越界 422 原样展示。
- `lib/units.ts`：界面单位 ⇄ 基准单位换算集中一处，条件输入按界面单位回显、
  提交前换回基准单位（引擎只认基准单位，库里存的也永远是基准单位）。
- `SelectionStrategyForm` 取代 `StrategyParamsForm`：一个策略只定义「怎么选」
  （股票池 + 因子 + 过滤条件），条件字段来自字段库接口而不是前端硬编码枚举。

因子参数化（名字即身份，界面不许藏）：
- `/factors` 新增「参数」列与展开行：精确引擎键、每个参数的允许范围、来源、依赖列
  （依赖列标明「引擎事实，不可改」）；说明文案从「不可修改」改为
  「改参数 = 新建参数化因子 = 新身份，旧因子/既有策略不变义」。
- 「新建参数化因子」卡片：模板下拉 + 受控窗口（min/max）+ 方向枚举下拉，
  实时预览规范键/中文名/渲染公式；后端 422 的原文原样展示，不静默截断。
- 因子下拉显示中文名（含参数）与短键，**value 一律是完整引擎键**；
  停用的因子从各页候选里消失（/strategies、/selection、/signals、/factors/compose），
  既有策略/归档仍按名字解析；`/factors/compose` 顺手修了勾选框点击目标过小。
- `/fields` 加提示：字段库只列内置因子名，参数化因子在 /factors 管理，
  选股策略条件下拉里会一并出现。

tsc --noEmit 0 error；verify_ui_alignment 8 页 160 项全过（另跑 3 个选因子页 51/54）。

frontend/web/app/backtest/page.tsx

@@ -1,266 +1,246 @@
 "use client";
 
 /**
- * 选股回测页 —— 研究闭环里的「定规则 + 验证」环节。
+ * 回测组合（/backtest）—— 选若干选股策略 + 填回测参数 → 保存为组合 / 直接运行。
  *
- * 本页承担三种进入方式（都可分享 URL）：
- * - 直接进入：从默认参数开始调；
- * - `?strategy=STG-xxx`：从策略库载入一个已保存策略（可微调、可另存）；
- * - `?from_selection=SEL-xxx`：从选股结果直通过来，预填当时的条件/因子/TopN
- *   （解决「选出来的股票要手工抄到回测页」的断点）；
- * - `?from_experiment=EXP-xxx`：从实验详情「以此参数再跑一次」进来。
+ * 2026-09 重构后这里是回测的**唯一产品入口**：
+ * - 选股策略（怎么选股）来自 /strategies；
+ * - 费率 / 复权口径来自 /settings（公共配置，本页只读展示）；
+ * - 本页只定「回测时才定的参数」：起始资金、持仓数 N、持仓天数区间 [Tmin,Tmax]、
+ *   调仓时机（日/周/月）、回测区间。
  *
- * 交互改进：参数区与说明/公式同屏（说明随参数实时更新，由后端推导）；
- * 「保存为策略」把当前参数存进策略库；结果区所有股票代码都带名称且可点进个股页。
+ * 进入方式（都可分享 URL）：
+ * - 直接进入：空组合开始；
+ * - `?combo=CMB-xxx`：载入已保存组合；
+ * - `?strategy=STG-xxx`：预先把该选股策略勾进组合（从策略库「加入回测组合」过来）。
  */
-import { Suspense, useEffect, useMemo, useRef, useState } from "react";
+import { Suspense, useCallback, useEffect, useMemo, useRef, useState } from "react";
 import Link from "next/link";
 import { useSearchParams } from "next/navigation";
-import { apiGet, apiPost } from "@/lib/api";
-import { STAGE_LABEL, submitJob, waitJob } from "@/lib/jobs";
+import { apiDelete, apiGet, apiPost, apiPut } from "@/lib/api";
+import { STAGE_LABEL, runSavedCombo, submitComboJob, waitJob } from "@/lib/jobs";
 import { recentRange } from "@/lib/dates";
-import type {
-  ActionRecord,
-  BacktestResult,
-  FactorMeta,
-  ResearchCondition,
-  ResearchSpec,
-  SelectionResult,
-  StrategyDefinition,
-  SymbolCurve,
-} from "@/lib/types";
-import { PageHeader, Card, Pill, Btn, Banner, Empty, Loading } from "@/components/ui";
-import {
-  StrategyParamsForm,
-  casePreset,
-  emptyParams,
-  paramsFromSpec,
-  paramsFromStrategy,
-  strategyFromParams,
-  validateParams,
-  type StrategyParams,
-} from "@/components/StrategyParamsForm";
-import { StrategyDocCard } from "@/components/StrategyDocCard";
+import type { BacktestCombo, BacktestResult, GlobalConfig, SelectionStrategy } from "@/lib/types";
+import { PageHeader, Card, Pill, Btn, Banner, Empty, Loading, Field, Progress, BacktestMetrics } from "@/components/ui";
 import { BacktestResultView } from "@/components/BacktestResultView";
 import { adjustLabel } from "@/lib/labels";
-import { useStrategyDoc } from "@/lib/strategy";
-import { SymbolLink, useSymbolNames } from "@/lib/symbols";
 
-type LoadState = { kind: "none" | "strategy" | "selection" | "experiment"; label: string; note?: string };
-
-/**
- * Next 15 要求使用 `useSearchParams` 的组件处于 Suspense 边界内，
- * 否则静态渲染阶段会报错（本页用 query 决定「从策略/选股/实验载入」）。
- */
 export default function BacktestPage() {
   return (
-    <Suspense fallback={<Loading label="加载回测页…" />}>
+    <Suspense fallback={<Loading label="加载回测组合页…" />}>
       <BacktestInner />
     </Suspense>
   );
 }
 
+interface Draft {
+  name: string;
+  description: string;
+  strategyIds: string[];
+  initialCapital: number;
+  holdCount: number;
+  holdMinDays: number;
+  holdMaxDays: number | null; // null = 不强制了结
+  rebalanceFreq: "daily" | "weekly" | "monthly";
+  start: string;
+  end: string;
+}
+
+function emptyDraft(range: { start: string; end: string }): Draft {
+  return {
+    name: "",
+    description: "",
+    strategyIds: [],
+    initialCapital: 1_000_000,
+    holdCount: 20,
+    holdMinDays: 0,
+    holdMaxDays: null,
+    rebalanceFreq: "monthly",
+    start: range.start,
+    end: range.end,
+  };
+}
+
+function draftToCombo(d: Draft): BacktestCombo {
+  return {
+    name: d.name.trim(),
+    description: d.description.trim(),
+    strategy_ids: d.strategyIds,
+    initial_capital: d.initialCapital,
+    hold_count: d.holdCount,
+    hold_min_days: d.holdMinDays,
+    hold_max_days: d.holdMaxDays,
+    rebalance_freq: d.rebalanceFreq,
+    period: [d.start, d.end],
+  };
+}
+
+function comboToDraft(c: BacktestCombo): Draft {
+  return {
+    name: c.name,
+    description: c.description ?? "",
+    strategyIds: [...c.strategy_ids],
+    initialCapital: c.initial_capital,
+    holdCount: c.hold_count,
+    holdMinDays: c.hold_min_days,
+    holdMaxDays: c.hold_max_days,
+    rebalanceFreq: c.rebalance_freq,
+    start: c.period[0],
+    end: c.period[1],
+  };
+}
+
+/** 调仓时机中文标签（列表与摘要共用，避免两处写法漂移）。 */
+const FREQ_LABEL: Record<Draft["rebalanceFreq"], string> = {
+  daily: "每日",
+  weekly: "每周",
+  monthly: "每月",
+};
+
+function validateDraft(d: Draft, strategies: SelectionStrategy[]): Record<string, string> {
+  const e: Record<string, string> = {};
+  if (!d.strategyIds.length) e.strategies = "至少选择一个选股策略";
+  else {
+    const missing = d.strategyIds.filter((id) => !strategies.some((s) => s.id === id));
+    if (missing.length) e.strategies = `以下选股策略已不存在，请移除：${missing.join(", ")}`;
+  }
+  if (d.holdCount < 1) e.holdCount = "持仓数 N 至少为 1";
+  if (d.holdMinDays < 0) e.holdMinDays = "Tmin 不能为负";
+  if (d.holdMaxDays !== null && d.holdMaxDays < 1) e.holdMaxDays = "Tmax 至少为 1 天";
+  if (d.holdMaxDays !== null && d.holdMinDays > 0 && d.holdMaxDays < d.holdMinDays)
+    e.holdMaxDays = `Tmax=${d.holdMaxDays} 不能小于 Tmin=${d.holdMinDays}`;
+  if (d.initialCapital < 10000) e.capital = "起始资金建议 ≥ 1 万";
+  if (!d.start || !d.end) e.period = "起止日期都必填";
+  else if (d.start >= d.end) e.period = "开始日期必须早于结束日期";
+  return e;
+}
+
 function BacktestInner() {
   const search = useSearchParams();
-  const strategyId = search.get("strategy");
-  const selectionId = search.get("from_selection");
-  const experimentId = search.get("from_experiment");
+  const comboId = search.get("combo");
+  const presetStrategy = search.get("strategy");
 
   const range = useMemo(() => recentRange(), []);
-  const [params, setParams] = useState<StrategyParams | null>(null);
-  const [factors, setFactors] = useState<FactorMeta[]>([]);
-  const [loaded, setLoaded] = useState<LoadState>({ kind: "none", label: "" });
+  const [strategies, setStrategies] = useState<SelectionStrategy[]>([]);
+  const [config, setConfig] = useState<GlobalConfig | null>(null);
+  const [combos, setCombos] = useState<BacktestCombo[] | null>(null);
+  const [draft, setDraft] = useState<Draft>(emptyDraft(range));
+  const [savedComboId, setSavedComboId] = useState<string | null>(null);
   const [result, setResult] = useState<BacktestResult | null>(null);
   const [running, setRunning] = useState(false);
+  const [runningComboId, setRunningComboId] = useState<string | null>(null);
   const [jobId, setJobId] = useState("");
   const [stage, setStage] = useState("");
   const [elapsed, setElapsed] = useState(0);
   const [error, setError] = useState("");
   const [notice, setNotice] = useState("");
   const [saving, setSaving] = useState(false);
-  const [lastExp, setLastExp] = useState<string | null>(null);
-  const [archiveId, setArchiveId] = useState("");
-  const [restoring, setRestoring] = useState(false);
+  const [deletingComboId, setDeletingComboId] = useState<string | null>(null);
+  const [revealErrors, setRevealErrors] = useState(false);
   const bootstrapped = useRef(false);
 
-  /* ---------- 初始化：因子表 + 默认/来源参数 ---------- */
+  /* ---------- 初始化：策略列表 + 公共配置 + 已保存组合 + 来源载入 ---------- */
   useEffect(() => {
     let alive = true;
-    apiGet<FactorMeta[]>("/factors")
-      .then((list) => alive && setFactors(list))
+    Promise.all([
+      apiGet<SelectionStrategy[]>("/strategies"),
+      apiGet<GlobalConfig>("/config"),
+    ])
+      .then(([sts, cfg]) => {
+        if (!alive) return;
+        setStrategies(sts);
+        setConfig(cfg);
+      })
       .catch((e: Error) => alive && setError(e.message));
+    // 组合库单独拉取：即便它失败，也不该连累策略列表与公共配置（否则整页只剩一条错误）。
+    apiGet<BacktestCombo[]>("/combos")
+      .then((cbs) => {
+        if (alive) setCombos(cbs);
+      })
+      .catch((e: Error) => {
+        if (!alive) return;
+        setError(e.message);
+        // 给空列表，否则「组合库」会永远停在加载中
+        setCombos((prev) => prev ?? []);
+      });
     return () => {
       alive = false;
     };
   }, []);
 
+  const loadCombos = useCallback(async () => {
+    try {
+      setCombos(await apiGet<BacktestCombo[]>("/combos"));
+    } catch (e) {
+      setError((e as Error).message);
+      setCombos([]);
+    }
+  }, []);
+
   useEffect(() => {
     if (bootstrapped.current) return;
     bootstrapped.current = true;
-    const base = emptyParams(range);
-    try {
-      const prev = window.localStorage.getItem("qlib:last-backtest-experiment");
-      if (prev) setLastExp(prev);
-    } catch {
-      /* localStorage 不可用（隐私模式）：只是少一个便捷入口，不影响主流程 */
-    }
-
     (async () => {
-      // 1) 策略库载入
-      if (strategyId) {
+      if (comboId) {
         try {
-          const st = await apiGet<StrategyDefinition>(`/strategies/${encodeURIComponent(strategyId)}`);
-          setParams({ ...paramsFromStrategy(st, base), start: base.start, end: base.end });
-          setLoaded({
-            kind: "strategy",
-            label: `来自策略库：${st.name}（${st.id}）`,
-            note: "参数已载入；改完可「另存为新策略」或直接运行回测。",
-          });
+          const c = await apiGet<BacktestCombo>(`/combos/${encodeURIComponent(comboId)}`);
+          setDraft(comboToDraft(c));
+          setSavedComboId(c.id ?? null);
+          setNotice(`已载入回测组合「${c.name}」（${c.id}）`);
           return;
         } catch (e) {
-          setError(`策略 ${strategyId} 载入失败：${(e as Error).message}`);
+          setError(`回测组合 ${comboId} 载入失败：${(e as Error).message}`);
         }
       }
-      // 2) 选股结果直通：把当时的口径原样搬过来
-      if (selectionId) {
-        try {
-          const sel = await apiGet<SelectionResult>(`/selections/${encodeURIComponent(selectionId)}`);
-          // 选股把当时的查询原样存进 config_snapshot（复现用），这里据此预填
-          const snapQ = (sel.config_snapshot ?? {}) as {
-            universe?: { exclude_st?: boolean; min_listing_days?: number };
-            price_adjustment?: "none" | "qfq" | "hfq";
-            factors?: { name: string; weight: number }[];
-            conditions?: ResearchCondition[];
-            top_n?: number | null;
-          };
-          const topNQ = snapQ.top_n ?? base.topN;
-          setParams({
-            ...base,
-            factors: snapQ.factors?.length ? snapQ.factors.map((f) => ({ ...f })) : base.factors,
-            conditions: (snapQ.conditions ?? []).map((c) => ({ ...c })),
-            topN: topNQ,
-            holdX: Math.max(1, Math.min(topNQ, base.holdX)),
-            excludeSt: snapQ.universe?.exclude_st ?? base.excludeSt,
-            minListingDays: snapQ.universe?.min_listing_days ?? base.minListingDays,
-            priceAdjustment: snapQ.price_adjustment ?? base.priceAdjustment,
-            start: base.start,
-            end: base.end,
-          });
-          setLoaded({
-            kind: "selection",
-            label: `来自选股 ${sel.as_of_date}（${sel.method}）`,
-            note:
-              "已把该次选股的**规则**（条件/因子/TopN/口径）预填为回测参数。" +
-              "注意：回测会在每个择股日按同一规则重新选股，而不是固定持有该次选出的这批股票。",
-          });
-          return;
-        } catch (e) {
-          setError(`选股结果 ${selectionId} 载入失败：${(e as Error).message}`);
-        }
+      if (presetStrategy) {
+        setDraft((d) => ({ ...d, strategyIds: [presetStrategy] }));
+        setNotice(`已把选股策略 ${presetStrategy} 预勾选进组合 —— 可再加其它策略、填好参数后运行。`);
       }
-      // 3) 实验参数复用
-      if (experimentId) {
-        try {
-          const exp = await apiGet<{ result?: BacktestResult & { config_snapshot?: Record<string, unknown> } }>(
-            `/experiments/${encodeURIComponent(experimentId)}`
-          );
-          const snap = exp.result?.config_snapshot as Partial<ResearchSpec> | undefined;
-          if (snap) {
-            setParams(paramsFromSpec(snap, base));
-            setLoaded({
-              kind: "experiment",
-              label: `来自实验 ${experimentId}`,
-              note: exp.result?.equity_curve?.length
-                ? `已复刻该实验参数，并直接展示它的归档结果（未重跑）。归档快照请到 /experiments/${experimentId} 查看；改参数后可再跑一次并与它对比。`
-                : "已复刻该实验的参数，可改后重跑并与原实验对比。",
-            });
-            // 实验已归档完整结果：直接展示，省一次几分钟的重跑
-            if (exp.result?.equity_curve?.length) {
-              setResult(exp.result);
-              setLastExp(experimentId);
-              setArchiveId(experimentId); // 提示条里给「打开归档」入口
-            }
-            return;
-          }
-          setError(`实验 ${experimentId} 没有可复用的参数快照`);
-        } catch (e) {
-          const msg = (e as Error).message;
-          setError(`实验 ${experimentId} 载入失败：${msg}`);
-          // 归档可能已被删除：清掉 localStorage 里的指针，避免「载入上次结果」每次都给坏链接。
-          // 只清指针（不影响参数区），并且只有在确实是 404 时才清。
-          if (msg.includes("404")) {
-            try {
-              if (window.localStorage.getItem("qlib:last-backtest-experiment") === experimentId) {
-                window.localStorage.removeItem("qlib:last-backtest-experiment");
-                setLastExp(null);
-              }
-            } catch {
-              /* localStorage 不可用：无需清理 */
-            }
-          }
-        }
-      }
-      setParams(base);
     })();
-    // 仅首次进入时按 URL 载入
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, []);
 
-  // 提交被拦下过 → 立即展开所有校验错误（否则用户只看到顶部一条，不知道还有哪些字段有问题）
-  const [revealErrors, setRevealErrors] = useState(false);
-  const errors = params ? validateParams(params, { requireMeta: params.name.trim() !== "" }) : {};
-  const blocking = ["topN", "holdX", "factors", "mMonths", "yMonths", "costs", "capital", "period", "conditions"].filter(
-    (k) => errors[k]
-  );
-  const doc = useStrategyDoc(params);
+  const errors = validateDraft(draft, strategies);
+  const blocking = Object.keys(errors);
+
+  function toggleStrategy(id: string) {
+    setDraft((d) => ({
+      ...d,
+      strategyIds: d.strategyIds.includes(id)
+        ? d.strategyIds.filter((x) => x !== id)
+        : [...d.strategyIds, id],
+    }));
+  }
 
   async function run() {
-    if (!params) return;
     if (blocking.length) {
       setError(errors[blocking[0]]);
       setRevealErrors(true);
-      // 焦点管理：直接把人带到出问题的控件上，而不是只丢一句提示让人自己找
       requestAnimationFrame(() => {
-        const el = document.querySelector<HTMLElement>(".input--invalid, .field--invalid input");
-        el?.focus();
+        const el = document.querySelector<HTMLElement>(".input--invalid, .field--invalid");
         el?.scrollIntoView({ block: "center", behavior: "smooth" });
       });
       return;
     }
+    await runVia(() => submitComboJob(draftToCombo(draft)), null);
+  }
+
+  /**
+   * 共用的「提交 Job → 轮询 → 出结果」管道。
+   *
+   * 两条入口共用：① 用页面上的草稿运行（临时组合，不落库）；② 从组合库直接运行已保存组合
+   * （走 POST /combos/{id}/run，跑库里那份参数）。抽出来是为了让两条路径的阶段显示、
+   * 归档提示、错误处理完全一致，不会一条修了另一条忘了。
+   */
+  async function runVia(submit: () => Promise<{ job_id: string }>, comboId: string | null) {
     setRunning(true);
+    setRunningComboId(comboId);
     setError("");
     setNotice("");
     setJobId("");
-    setArchiveId("");
     setResult(null);
     try {
-      const spec = {
-        type: "backtest" as const,
-        universe: { exclude_st: params.excludeSt, min_listing_days: params.minListingDays },
-        price_adjustment: params.priceAdjustment,
-        factors: params.factors.filter((f) => f.name.trim() !== ""),
-        conditions: params.conditions.filter((c) => c.field.trim() !== ""),
-        selection: {
-          top_n: params.topN,
-          hold_top_x: params.holdX,
-          allow_substitute: params.fillPolicy === "substitute",
-          defer_buy: params.fillPolicy === "defer",
-        },
-        rebalance: params.rebalance,
-        selection_interval_months:
-          params.mMonths > 0 ? params.mMonths : params.yMonths > 0 ? params.yMonths : null,
-        rebalance_interval_months:
-          params.yMonths > 0 ? params.yMonths : params.mMonths > 0 ? params.mMonths : null,
-        costs: {
-          commission_rate: params.commission / 100,
-          stamp_tax_rate: params.stamp / 100,
-          slippage_rate: params.slippage / 100,
-          min_commission: params.minCommission,
-        },
-        initial_capital: params.capital,
-        period: [params.start, params.end] as [string, string],
-      };
-      const { job_id } = await submitJob(spec);
+      const { job_id } = await submit();
       setJobId(job_id);
       setStage("queued");
       const out = await waitJob<BacktestResult>(job_id, 900_000, (info) => {
@@ -270,20 +250,7 @@ function BacktestInner() {
       if (out.status === "success" && out.result) {
         setResult(out.result);
         const exp = out.experimentId ?? null;
-        if (exp) {
-          setLastExp(exp);
-          setArchiveId(exp);
-          try {
-            window.localStorage.setItem("qlib:last-backtest-experiment", exp);
-          } catch {
-            /* 忽略：仅影响下次进入的便捷入口 */
-          }
-        }
-        setNotice(
-          exp
-            ? `回测完成，已归档为实验 ${exp}（可在「实验对比」页与其它版本对比）。`
-            : "回测完成，已自动归档到「实验对比」页。"
-        );
+        setNotice(exp ? `回测完成，已归档为实验 ${exp}（可在「实验对比」页与其它版本对比）。` : "回测完成，已自动归档。");
       } else {
         setError(`任务${out.status}${out.error ? `：${out.error}` : ""}`);
       }
@@ -291,44 +258,83 @@ function BacktestInner() {
       setError((e as Error).message);
     } finally {
       setRunning(false);
+      setRunningComboId(null);
       setJobId("");
     }
   }
 
-  /** 载入上次回测结果：避免刷新页面后必须重跑一个几分钟的作业 */
-  async function loadLast() {
-    if (!lastExp) return;
-    setRestoring(true);
+  /* ---------- 组合库操作 ---------- */
+
+  /** 把库里的一份组合回填到表单（不自动运行，先把参数摆出来给用户看/改）。 */
+  function loadCombo(c: BacktestCombo) {
+    setDraft(comboToDraft(c));
+    setSavedComboId(c.id ?? null);
+    setError("");
+    setRevealErrors(false);
+    setNotice(`已载入回测组合「${c.name}」（${c.id}）—— 可直接运行，或改完参数再「更新组合」。`);
+  }
+
+  /** 用库里的参数直接运行（不掺入表单里未保存的改动）。 */
+  async function runSaved(c: BacktestCombo) {
+    if (!c.id) return;
+    setDraft(comboToDraft(c));
+    setSavedComboId(c.id);
+    await runVia(() => runSavedCombo(c.id as string), c.id);
+  }
+
+  /** 清空表单，开始一个新组合（不影响库里已有的）。 */
+  function startNewCombo() {
+    setDraft(emptyDraft(range));
+    setSavedComboId(null);
+    setResult(null);
+    setNotice("已清空表单，开始一个新组合。");
+    setError("");
+    setRevealErrors(false);
+  }
+
+  async function removeCombo(c: BacktestCombo) {
+    if (!c.id) return;
+    if (!window.confirm(`删除回测组合「${c.name}」（${c.id}）？此操作不可撤销（归档结果不受影响）。`)) {
+      return;
+    }
+    setDeletingComboId(c.id);
     setError("");
     try {
-      const exp = await apiGet<{ result?: BacktestResult }>(`/experiments/${encodeURIComponent(lastExp)}`);
-      if (exp.result?.equity_curve?.length) {
-        setResult(exp.result);
-        setArchiveId(lastExp);
-        setNotice(`已载入上次归档结果（${lastExp}），未重新执行作业。`);
-      } else {
-        setError(`实验 ${lastExp} 没有可载入的回测结果`);
-      }
+      await apiDelete(`/combos/${encodeURIComponent(c.id)}`);
+      if (savedComboId === c.id) setSavedComboId(null);
+      setNotice(`已删除回测组合「${c.name}」。`);
+      await loadCombos();
     } catch (e) {
       setError((e as Error).message);
     } finally {
-      setRestoring(false);
+      setDeletingComboId(null);
     }
   }
 
-  async function saveAsStrategy() {
-    if (!params) return;
-    const need = validateParams(params, { requireMeta: true });
-    if (Object.keys(need).length) {
-      setError(Object.values(need)[0]);
+  async function saveCombo() {
+    if (blocking.length) {
+      setError(errors[blocking[0]]);
+      setRevealErrors(true);
+      return;
+    }
+    if (!draft.name.trim()) {
+      setError("保存组合需要起个名字");
+      setRevealErrors(true);
       return;
     }
     setSaving(true);
     setError("");
     try {
-      const saved = await apiPost<StrategyDefinition>("/strategies", strategyFromParams(params));
-      setNotice(`已保存到策略库：「${saved.name}」（${saved.id}）—— 可在策略库一键回测/编辑。`);
-      setLoaded({ kind: "strategy", label: `已保存为策略 ${saved.name}（${saved.id}）` });
+      const combo = draftToCombo(draft);
+      if (savedComboId) {
+        await apiPut<BacktestCombo>(`/combos/${encodeURIComponent(savedComboId)}`, combo);
+        setNotice(`已更新回测组合「${combo.name}」`);
+      } else {
+        const saved = await apiPost<BacktestCombo>("/combos", combo);
+        setSavedComboId(saved.id ?? null);
+        setNotice(`已保存回测组合「${saved.name}」（${saved.id}）`);
+      }
+      await loadCombos();
     } catch (e) {
       setError((e as Error).message);
     } finally {
@@ -336,126 +342,289 @@ function BacktestInner() {
     }
   }
 
+  const showErr = (k: string) => (revealErrors ? errors[k] : undefined);
+
   return (
     <>
       <PageHeader
-        title="选股回测"
-        sub="两级截断择股（候选池 n → 持仓 x）+ 择股/调仓双周期（m/y），收盘价撮合，买卖点与个股收益曲线可视化，结果自动归档可复现。"
+        title="回测组合"
+        sub="选一个或多个选股策略，填上回测参数（资金/持仓/持仓天数区间/调仓时机/区间），保存为组合或直接运行；已保存的组合在下方「组合库」里可载入、直接运行、删除。费率与复权口径取自公共配置。"
         actions={
           <div className="row" style={{ gap: 8 }}>
-            <Link href="/strategies" className="btn">
-              <span>策略库</span>
-            </Link>
-            <Link href="/experiments" className="btn">
-              <span>实验对比</span>
-            </Link>
+            <Link href="/strategies" className="btn"><span>选股策略库</span></Link>
+            <Link href="/settings" className="btn"><span>公共配置</span></Link>
+            <Link href="/experiments" className="btn"><span>实验对比</span></Link>
           </div>
         }
       />
 
-      {lastExp && !result && !running ? (
-        <div className="sticky-bar" style={{ position: "static" }}>
-          <Pill tone="accent" icon="archive">
-            上次结果
-          </Pill>
-          <span className="hint">
-            本机上次回测已归档为实验 <span className="mono">{lastExp}</span>；
-            直接载入可省去重跑（全市场 8 年区间约 3~5 分钟）。
-          </span>
-          <Btn size="sm" icon="refresh" loading={restoring} disabled={restoring} onClick={loadLast}>
-            载入上次结果
-          </Btn>
-          <Btn
-            size="sm"
-            icon="x"
-            onClick={() => {
-              setLastExp(null);
-              try {
-                window.localStorage.removeItem("qlib:last-backtest-experiment");
-              } catch {
-                /* 忽略 */
-              }
-            }}
-          >
-            忽略
-          </Btn>
-        </div>
-      ) : null}
-
-      {loaded.kind !== "none" ? (
-        <Banner tone="info">
-          {loaded.label}
-          {loaded.note ? ` · ${loaded.note}` : ""}
-        </Banner>
-      ) : null}
       {error ? <Banner tone="error">{error}</Banner> : null}
-      {notice ? (
-        <Banner tone="info">
-          {notice}
-          {archiveId ? (
-            <>
-              {" "}
-              <Link href={`/experiments/${encodeURIComponent(archiveId)}`} className="btn btn--sm">
-                <span>打开归档（完整快照）</span>
-              </Link>
-            </>
-          ) : null}
-        </Banner>
+      {notice ? <Banner tone="info">{notice}</Banner> : null}
+
+      {/* 公共配置（只读） */}
+      {config ? (
+        <Card icon="database" title="本次回测采用的公共配置（只读）" tools={
+          <Link href="/settings" className="btn btn--sm"><span>去修改</span></Link>
+        }>
+          <div className="chips">
+            <span className="chip">佣金 <b>{(config.commission_rate * 100).toFixed(3)}%</b></span>
+            <span className="chip">印花税 <b>{(config.stamp_tax_rate * 100).toFixed(2)}%</b></span>
+            <span className="chip">滑点 <b>{(config.slippage_rate * 100).toFixed(2)}%</b></span>
+            <span className="chip">最低佣金 <b>{config.min_commission} 元</b></span>
+            <span className="chip">复权 <b>{adjustLabel(config.price_adjustment)}</b></span>
+            <span className="chip">基准 <b className="mono">{config.benchmark}</b></span>
+          </div>
+          <div className="hint" style={{ marginTop: 8 }}>
+            运行时这些值会被**快照**进归档，事后改公共配置不影响这次结果的数字。
+          </div>
+        </Card>
       ) : null}
 
+      {/* 组合库：保存过的组合在这里能被找回（否则「保存」等于存进黑洞） */}
       <Card
-        icon="gauge"
-        title="研究参数（Research Specification）"
+        icon="archive"
+        title={`已保存的回测组合${combos ? ` · ${combos.length}` : ""}`}
         tools={
           <div className="row" style={{ gap: 8 }}>
-            <Btn icon="target" disabled={running || !params} onClick={() => params && setParams({ ...casePreset(range), name: params.name, description: params.description })}>
-              载入高股息案例默认参数
+            <Btn size="sm" onClick={startNewCombo} disabled={running}>
+              新建组合
             </Btn>
-            <Btn icon="book" loading={saving} disabled={running || saving || !params} onClick={saveAsStrategy}>
-              保存为策略
+            <Btn size="sm" onClick={() => void loadCombos()}>
+              刷新
             </Btn>
           </div>
         }
       >
-        {params ? (
-          <>
-            <StrategyParamsForm
-              value={params}
-              onChange={setParams}
-              factorOptions={factors}
-              showMeta
-              showPeriod
-              disabled={running}
-              errors={errors}
-            revealErrors={revealErrors}
-            />
-            <div className="sticky-bar" style={{ marginTop: 14, position: "static" }}>
-              <Btn variant="primary" icon="play" loading={running} disabled={running} onClick={run}>
-                {running ? "后台运行中…" : "运行回测"}
-              </Btn>
-              <span className="hint">
-                n={params.topN} → x={params.holdX} · m={params.mMonths} / y={params.yMonths} ·{" "}
-                {adjustLabel(params.priceAdjustment)} · {params.start} ~ {params.end}
-              </span>
-              {blocking.length ? (
-                <Pill tone="warn" icon="alert">
-                  有 {blocking.length} 处参数需要修正
-                </Pill>
-              ) : (
-                <Pill tone="pos" icon="check">
-                  参数校验通过
-                </Pill>
-              )}
-            </div>
-          </>
+        {combos === null ? (
+          <Loading label="读取已保存的回测组合…" />
+        ) : combos.length === 0 ? (
+          <Empty
+            icon="archive"
+            title="还没有保存过回测组合"
+            hint="勾选策略、填好参数后点「保存为回测组合」，之后就能在这里一键载入或直接运行。"
+          />
         ) : (
-          <Loading label="准备参数…" />
+          <div className="combo-list">
+            {combos.map((c) => {
+              const isCurrent = savedComboId === c.id;
+              const isRunning = runningComboId === c.id;
+              return (
+                <div key={c.id ?? c.name} className={`combo-item${isCurrent ? " is-on" : ""}`}>
+                  <div className="combo-item__main">
+                    <div className="row" style={{ gap: 8, flexWrap: "wrap", alignItems: "center" }}>
+                      <b>{c.name}</b>
+                      {isCurrent ? (
+                        <Pill tone="violet" icon="check">当前载入</Pill>
+                      ) : null}
+                      {isRunning ? <Pill tone="warn">运行中…</Pill> : null}
+                      <span className="mono hint">{c.id}</span>
+                    </div>
+                    <div className="chips" style={{ marginTop: 6 }}>
+                      <span className="chip">持仓数 <b>{c.hold_count}</b></span>
+                      <span className="chip">
+                        持仓区间 <b>[{c.hold_min_days}, {c.hold_max_days ?? "∞"}] 天</b>
+                      </span>
+                      <span className="chip">调仓 <b>{FREQ_LABEL[c.rebalance_freq] ?? c.rebalance_freq}</b></span>
+                      <span className="chip">区间 <b>{c.period[0]} ~ {c.period[1]}</b></span>
+                      <span className="chip">引用策略 <b>{c.strategy_ids.length}</b> 个</span>
+                    </div>
+                    {c.description ? <div className="strategy-desc">{c.description}</div> : null}
+                  </div>
+                  <div className="strategy-actions">
+                    <Btn size="sm" icon="edit" disabled={running} onClick={() => loadCombo(c)}>
+                      载入到表单
+                    </Btn>
+                    <Btn
+                      size="sm"
+                      variant="primary"
+                      icon="play"
+                      loading={isRunning}
+                      disabled={running}
+                      onClick={() => void runSaved(c)}
+                    >
+                      直接运行
+                    </Btn>
+                    <Btn
+                      size="sm"
+                      variant="danger"
+                      icon="trash"
+                      loading={deletingComboId === c.id}
+                      disabled={running}
+                      onClick={() => void removeCombo(c)}
+                    >
+                      删除
+                    </Btn>
+                  </div>
+                </div>
+              );
+            })}
+          </div>
         )}
+        <div className="hint" style={{ marginTop: 8 }}>
+          「直接运行」用库里保存的那份参数（不受表单里未保存改动影响）；「载入到表单」把参数摆出来，
+          改完点上方「更新组合」覆盖，或直接点「运行回测组合」按当前草稿跑。
+        </div>
+      </Card>
+
+      {/* 选股策略多选 */}
+      <Card icon="book" title={`选择选股策略（已选 ${draft.strategyIds.length}）`} tools={
+        <span className="hint">多策略取并集后按 Borda 秩和统一打分排序</span>
+      }>
+        {strategies.length === 0 ? (
+          <Empty icon="book" title="还没有选股策略" hint={
+            <Link href="/strategies">先去策略库建一个「怎么选」的策略</Link>
+          } />
+        ) : (
+          <div className="strategy-pick">
+            {strategies.map((s) => {
+              const on = draft.strategyIds.includes(s.id ?? "");
+              return (
+                <label key={s.id} className={`strategy-pick__item${on ? " is-on" : ""}`}>
+                  <input
+                    type="checkbox"
+                    checked={on}
+                    onChange={() => s.id && toggleStrategy(s.id)}
+                    aria-label={`选择选股策略 ${s.name}`}
+                  />
+                  <span className="strategy-pick__name">{s.name}</span>
+                  <span className="strategy-pick__meta mono">{s.id}</span>
+                  <span className="strategy-pick__desc">{s.description || "（无说明）"}</span>
+                  <span className="strategy-pick__factors">
+                    {s.factors?.map((f) => f.name).join(" + ") || "—"}
+                  </span>
+                </label>
+              );
+            })}
+          </div>
+        )}
+        {showErr("strategies") && <div className="field-err" role="alert">{showErr("strategies")}</div>}
+      </Card>
+
+      {/* 回测参数 */}
+      <Card
+        icon="gauge"
+        title={savedComboId ? `回测参数 · 正在编辑组合 ${savedComboId}` : "回测参数 · 新组合"}
+        tools={
+          <div className="row" style={{ gap: 8 }}>
+            <Btn icon="book" loading={saving} disabled={running || saving} onClick={saveCombo}>
+              {savedComboId ? "更新组合" : "保存为回测组合"}
+            </Btn>
+          </div>
+        }
+      >
+        <div className="params-form">
+          <div className="form-grid">
+            <Field label="组合名称（保存时必填）" hint="便于在组合列表里识别">
+              <input
+                className={`input${showErr("name") ? " input--invalid" : ""}`}
+                value={draft.name}
+                maxLength={64}
+                placeholder="例：高股息双策略 · 月频"
+                disabled={running}
+                onChange={(e) => setDraft({ ...draft, name: e.target.value })}
+              />
+            </Field>
+            <Field
+              label="组合说明（可选）"
+              hint={`记下这个组合的用意（${draft.description.length}/300）`}
+              className="field--wide"
+            >
+              <input
+                className="input"
+                value={draft.description}
+                maxLength={300}
+                placeholder="例：用两个高股息选股策略取并集，月频调仓，验证 Tmax=30 天强制了结的影响"
+                disabled={running}
+                onChange={(e) => setDraft({ ...draft, description: e.target.value })}
+              />
+            </Field>
+            <Field label="起始资金（元）" hint="回测初始本金，默认 100 万">
+              <input
+                className={`input mono${showErr("capital") ? " input--invalid" : ""}`}
+                type="number" inputMode="numeric" step={100000} min={10000}
+                value={draft.initialCapital} disabled={running}
+                onChange={(e) => setDraft({ ...draft, initialCapital: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="持仓数 N" hint="目标等权持有的股票只数">
+              <input
+                className={`input mono${showErr("holdCount") ? " input--invalid" : ""}`}
+                type="number" inputMode="numeric" min={1} max={1000}
+                value={draft.holdCount} disabled={running}
+                onChange={(e) => setDraft({ ...draft, holdCount: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="调仓时机" hint="多久重新打分并调仓一次">
+              <select
+                className="input"
+                value={draft.rebalanceFreq} disabled={running}
+                onChange={(e) => setDraft({ ...draft, rebalanceFreq: e.target.value as Draft["rebalanceFreq"] })}
+              >
+                <option value="daily">每日</option>
+                <option value="weekly">每周</option>
+                <option value="monthly">每月</option>
+              </select>
+            </Field>
+            <Field label="最短持仓 Tmin（天）" hint="掉出 TopN 时未满此天数暂不卖（防频繁换手）；0=不保护">
+              <input
+                className={`input mono${showErr("holdMinDays") ? " input--invalid" : ""}`}
+                type="number" inputMode="numeric" min={0}
+                value={draft.holdMinDays} disabled={running}
+                onChange={(e) => setDraft({ ...draft, holdMinDays: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="最长持仓 Tmax（天）" hint="超过即强制了结（每个交易日检查）；留空=不限">
+              <div className="row" style={{ gap: 8, alignItems: "center" }}>
+                <input
+                  className={`input mono${showErr("holdMaxDays") ? " input--invalid" : ""}`}
+                  type="number" inputMode="numeric" min={1}
+                  value={draft.holdMaxDays ?? ""} disabled={running}
+                  placeholder="不限"
+                  onChange={(e) => setDraft({ ...draft, holdMaxDays: e.target.value === "" ? null : Number(e.target.value) })}
+                />
+                <label className="check" style={{ whiteSpace: "nowrap" }}>
+                  <input
+                    type="checkbox"
+                    checked={draft.holdMaxDays === null}
+                    disabled={running}
+                    onChange={(e) => setDraft({ ...draft, holdMaxDays: e.target.checked ? null : 30 })}
+                  />
+                  不限
+                </label>
+              </div>
+            </Field>
+            <Field label="开始日期" className={showErr("period") ? "field--invalid" : undefined}>
+              <input type="date" className="input" value={draft.start} disabled={running}
+                onChange={(e) => setDraft({ ...draft, start: e.target.value })} />
+            </Field>
+            <Field label="结束日期" className={showErr("period") ? "field--invalid" : undefined}>
+              <input type="date" className="input" value={draft.end} disabled={running}
+                onChange={(e) => setDraft({ ...draft, end: e.target.value })} />
+            </Field>
+          </div>
+          {showErr("period") && <div className="field-err" role="alert">{showErr("period")}</div>}
+
+          <div className="sticky-bar" style={{ marginTop: 14, position: "static" }}>
+            <Btn variant="primary" icon="play" loading={running} disabled={running} onClick={run}>
+              {running ? "后台运行中…" : "运行回测组合"}
+            </Btn>
+            <span className="hint">
+              N={draft.holdCount} · [{draft.holdMinDays}, {draft.holdMaxDays ?? "∞"}] 天 ·{" "}
+              {draft.rebalanceFreq === "daily" ? "日频" : draft.rebalanceFreq === "weekly" ? "周频" : "月频"} ·{" "}
+              {draft.start} ~ {draft.end} · {draft.strategyIds.length} 个策略
+            </span>
+            {blocking.length ? (
+              <Pill tone="warn" icon="alert">有 {blocking.length} 处需要修正</Pill>
+            ) : (
+              <Pill tone="pos" icon="check">参数校验通过</Pill>
+            )}
+          </div>
+        </div>
 
         {running ? (
           <div className="stages" style={{ marginTop: 12 }}>
-            {["data_loading", "selection", "backtesting", "analysis"].map((st) => {
-              const order = ["queued", "data_loading", "selection", "backtesting", "analysis", "done"];
+            {["data_loading", "backtesting", "analysis"].map((st) => {
+              const order = ["queued", "data_loading", "backtesting", "analysis", "done"];
               const cur = order.indexOf(stage);
               const mine = order.indexOf(st);
               const cls = mine < cur ? "stage is-done" : mine === cur ? "stage is-active" : "stage";
@@ -466,31 +635,21 @@ function BacktestInner() {
               );
             })}
             <span className="hint">
-              作业 <span className="mono">{jobId || "排队中…"}</span> · 已用{" "}
-              {Math.round(elapsed / 1000)}s（全市场 8 年区间约 3~5 分钟，可离开本页，结果会归档）
+              作业 <span className="mono">{jobId || "排队中…"}</span> · 已用 {Math.round(elapsed / 1000)}s
+              （全市场多年区间约 3~5 分钟，可离开本页，结果会归档）
             </span>
           </div>
         ) : null}
       </Card>
 
-      <StrategyDocCard
-        doc={doc.doc}
-        loading={doc.loading}
-        error={doc.error}
-        title="策略说明与计算公式（随参数实时更新）"
-      />
-
       {!result && !running && !error ? (
         <Card>
-          <Empty
-            icon="gauge"
-            title="尚未运行回测"
-            hint="可点「载入高股息案例默认参数」一键填充；调好后点「保存为策略」即可在策略库复用、对比。"
-          />
+          <Empty icon="gauge" title="尚未运行回测"
+            hint="先勾选至少一个选股策略、填好回测参数，再点「运行回测组合」。可先「保存为回测组合」以便复用。" />
         </Card>
       ) : null}
 
-      {result ? <BacktestResultView result={result} name={params?.name ?? ""} /> : null}
+      {result ? <BacktestResultView result={result} name={draft.name || "回测组合"} /> : null}
     </>
   );
 }

frontend/web/app/experiments/[id]/page.tsx

@@ -27,7 +27,7 @@ import { archivedFieldSummary } from "@/lib/archive";
 import { PageHeader, Card, Pill, Empty, Banner } from "@/components/ui";
 import { adjustLabel, experimentKindLabel, rebalanceLabel } from "@/lib/labels";
 import { RichText } from "@/components/RichText";
-import type { ExperimentDetail, FactorMeta, ResearchCondition, ResearchSpec, StrategyDoc } from "@/lib/types";
+import type { BacktestCombo, BacktestResult, ExperimentDetail, FactorMeta, ResearchCondition, ResearchSpec, StrategyDoc } from "@/lib/types";
 
 export const dynamic = "force-dynamic"; // 归档可能被删除/新增，禁止静态化缓存
 
@@ -74,14 +74,26 @@ export default async function ExperimentArchivePage({
   // 归档不存在 → 交给 Next 的 404（比渲染一个空壳页更诚实）
   if (!detail) notFound();
 
-  const spec = (detail.spec ?? null) as Partial<ResearchSpec> | null;
+  const rawSpec = (detail.spec ?? null) as Record<string, unknown> | null;
+  // 组合回测的归档：spec_json 是 BacktestCombo（含 strategy_ids/hold_count），不是 ResearchSpec。
+  // 用同一套「选股条件/交易执行依据」卡去解读它会满屏「未记录」—— 那是谎报。
+  // 这里识别出来交给专门的 ComboArchiveCards；成本/复权从 result.config_snapshot 取快照。
+  const isComboArchive =
+    detail.kind === "backtest" &&
+    !!rawSpec &&
+    (Array.isArray(rawSpec.strategy_ids) || "hold_count" in rawSpec);
   const result = detail.result;
+  const spec = isComboArchive ? null : (rawSpec as Partial<ResearchSpec> | null);
+  const comboSpec = isComboArchive ? (rawSpec as unknown as BacktestCombo) : null;
+  const comboCosts = isComboArchive
+    ? ((result as BacktestResult | null)?.config_snapshot as Record<string, unknown> | undefined)
+    : undefined;
   // 关键字段计数按 kind 给不同口径（用回测字段去数因子/选股结果是错的）
   const fieldSummary = archivedFieldSummary(detail.kind, result);
   // 与引擎执行规则同源的说明（后端按归档 spec 推导；推导失败时如实显示错误）
   // 只有回测归档才需要「完整说明与计算公式」：describe 推导的是回测策略口径，
   // 因子测试/选股用同一 spec 结构但规则并未执行，拉回来展示等于误导（且白花一次请求）。
-  const doc = spec && detail.kind === "backtest"
+  const doc = spec && detail.kind === "backtest" && !isComboArchive
     ? await serverPost<StrategyDoc & { doc?: StrategyDoc }>("/strategies/describe", spec)
     : null;
   const docBody = doc ? ((doc as { doc?: StrategyDoc }).doc ?? doc) : null;
@@ -95,9 +107,9 @@ export default async function ExperimentArchivePage({
 
       <ArchiveActions id={detail.id} spec={detail.spec} />
 
-      <ArchivedSpecCards detail={detail} spec={spec} factors={factors ?? []} />
+      <ArchivedSpecCards detail={detail} spec={spec} factors={factors ?? []} combo={comboSpec} comboCosts={comboCosts} />
 
-      {detail.kind === "backtest" ? (
+      {detail.kind === "backtest" && !isComboArchive ? (
         <StrategyDocCard
           doc={docBody}
           loading={false}
@@ -237,6 +249,66 @@ function condText(c: ResearchCondition): string {
  * （含 `selection` / `costs` / `initial_capital`）—— 把这些字段按回测口径展示，
  * 会让人以为这次跑过调仓与撮合。所以这里只列生效项，并显式说明哪些字段未生效。
  */
+/**
+ * 组合回测归档的 spec 卡：如实展示「引用了哪些选股策略 + 回测参数 + 成本/复权快照」。
+ *
+ * 关键点（诚实性，AGENT §7/§24）：组合归档的 spec_json 是 BacktestCombo，不含
+ * factors/selection/costs；成本与复权在运行时从公共配置快照进了 result.config_snapshot，
+ * 这里从 `costs`（即 config_snapshot）读取并明确标注「来自运行时的公共配置快照」。
+ */
+function ComboArchiveCards({
+  combo,
+  costs,
+}: {
+  combo: BacktestCombo;
+  costs?: Record<string, unknown>;
+}) {
+  const costObj = (costs?.costs ?? {}) as Record<string, number>;
+  const adj = String(costs?.price_adjustment ?? "未记录");
+  const freqLabel =
+    combo.rebalance_freq === "daily" ? "每日" : combo.rebalance_freq === "weekly" ? "每周" : "每月";
+  return (
+    <Card
+      icon="layers"
+      title="回测组合（本次实际使用的规则）"
+      tools={<Pill tone="violet">来自归档 spec + 运行时配置快照</Pill>}
+    >
+      <div className="spec-grid">
+        <SpecBlock title="引用的选股策略">
+          {(combo.strategy_ids ?? []).length === 0 ? (
+            <SpecRow k="策略" v="—" />
+          ) : (
+            (combo.strategy_ids ?? []).map((id) => (
+              <SpecRow key={id} k={id} v="选股条件组合（详见策略库）" mono />
+            ))
+          )}
+          <SpecRow k="打分方式" v="多策略取并集后 Borda 秩和统一排序" />
+        </SpecBlock>
+        <SpecBlock title="回测参数">
+          <SpecRow k="持仓数 N" v={String(combo.hold_count ?? "—")} />
+          <SpecRow k="持仓天数区间" v={`[${combo.hold_min_days ?? 0}, ${combo.hold_max_days ?? "∞"}] 天`} />
+          <SpecRow k="调仓时机" v={freqLabel} />
+          <SpecRow k="起始资金" v={`${Number(combo.initial_capital ?? 0).toLocaleString()} 元`} />
+          <SpecRow k="回测区间" v={combo.period ? `${combo.period[0]} ~ ${combo.period[1]}` : "—"} mono />
+        </SpecBlock>
+        <SpecBlock title="交易执行依据（来自运行时的公共配置快照）">
+          <SpecRow k="佣金" v={costObj.commission_rate != null ? `${(costObj.commission_rate * 100).toFixed(3)}%（买卖各一次）` : "未记录"} />
+          <SpecRow k="印花税" v={costObj.stamp_tax_rate != null ? `${(costObj.stamp_tax_rate * 100).toFixed(2)}%（仅卖出）` : "未记录"} />
+          <SpecRow k="滑点" v={costObj.slippage_rate != null ? `${(costObj.slippage_rate * 100).toFixed(2)}%` : "未记录"} />
+          <SpecRow k="最低佣金" v={costObj.min_commission != null ? `${costObj.min_commission} 元/笔` : "未启用"} />
+          <SpecRow k="复权口径" v={adj === "hfq" ? "后复权 hfq" : adj === "qfq" ? "前复权 qfq" : adj === "none" ? "不复权" : adj} />
+          <SpecRow k="成交时点" v="调仓日收盘（调仓在当日收盘生效，自次日起计收益）" />
+          <SpecRow k="Tmax 强制了结" v="每个交易日检查；超过最长持仓天数即卖出" />
+          <SpecRow k="Tmin 保护" v="掉出 TopN 但未满最短持仓天数时暂不卖（防频繁换手）" />
+        </SpecBlock>
+      </div>
+      <div className="hint" style={{ marginTop: 10 }}>
+        <RichText text="这是一次**回测组合**归档：它引用了上面的选股策略（「怎么选」），并用这里的回测参数（资金/持仓/持仓天数区间/调仓时机）执行。成本与复权是**运行那一刻从公共配置快照**下来的，所以即使之后改了公共配置，本归档的数字也不会变 —— 这正是可复现的依据。" />
+      </div>
+    </Card>
+  );
+}
+
 function FactorTestSpecCards({
   spec,
   factors,
@@ -377,11 +449,21 @@ function ArchivedSpecCards({
   detail,
   spec,
   factors,
+  combo,
+  comboCosts,
 }: {
   detail: ExperimentDetail;
   spec: Partial<ResearchSpec> | null;
   factors: FactorMeta[];
+  combo?: BacktestCombo | null;
+  comboCosts?: Record<string, unknown>;
 }) {
+  // 组合回测归档：spec 是 BacktestCombo，用专属卡片如实展示（引用的策略 + 回测参数 +
+  // 从 config_snapshot 取的成本/复权快照）。绝不能套单策略回测的「选股条件/交易执行依据」。
+  if (combo) {
+    return <ComboArchiveCards combo={combo} costs={comboCosts} />;
+  }
+
   if (!spec) {
     return (
       <Card icon="book" title="选股条件与交易执行依据">

frontend/web/app/factors/compose/page.tsx

@@ -3,6 +3,7 @@
 import { useEffect, useState } from "react";
 import { apiGet } from "@/lib/api";
 import { submitJob, waitJob } from "@/lib/jobs";
+import { factorLabel, pickableFactors } from "@/lib/factors";
 import type { BacktestResult, FactorMeta, ResearchSpec } from "@/lib/types";
 import { recentRange } from "@/lib/dates";
 import {
@@ -45,7 +46,8 @@ export default function ComposePage() {
     apiGet<FactorMeta[]>("/factors")
       .then((list) => {
         if (!alive) return;
-        setFactors(list);
+        // 停用/算不出来的因子不摆进候选（停用仍可被既有策略解析，只是不该再被选中）
+        setFactors(pickableFactors(list));
         setPicks([
           { name: "momentum_60", weight: 1.5 },
           { name: "volatility_60", weight: 1.0 },
@@ -159,15 +161,23 @@ export default function ComposePage() {
                 return (
                   <tr key={f.name} className={pick ? "row-active" : undefined}>
                     <td>
-                      <input
-                        type="checkbox"
-                        checked={!!pick}
-                        onChange={() => togglePick(f.name)}
-                        aria-label={`选择因子 ${f.name}`}
-                      />
+                      {/* 勾选框要用 .check--cell 包一层：裸 16px 的 checkbox 点击目标太小
+                          （本项目 UI 自检要求 ≥28px，且与同排输入框等高） */}
+                      <label className="check check--cell">
+                        <input
+                          type="checkbox"
+                          checked={!!pick}
+                          onChange={() => togglePick(f.name)}
+                          aria-label={`选择因子 ${f.name}`}
+                        />
+                      </label>
                     </td>
                     <td className="cell-strong">
-                      <span className="mono">{f.name}</span>
+                      {factorLabel(f)}
+                      {/* 名字即身份：中文名旁边的引擎键必须看得见（含参数，如 momentum(window=90,…)） */}
+                      <span className="hint mono cell-hint" style={{ fontWeight: 400, overflowWrap: "anywhere" }}>
+                        {f.name}
+                      </span>
                     </td>
                     <td>
                       <Pill tone={f.direction === "higher_is_better" ? "accent" : "violet"}>

frontend/web/app/factors/page.tsx

@@ -1,9 +1,15 @@
 "use client";
 
-import { useEffect, useState } from "react";
-import { apiGet } from "@/lib/api";
+import { useCallback, useEffect, useState } from "react";
+import { apiGet, apiPatch, apiPost } from "@/lib/api";
 import { submitJob, waitJob } from "@/lib/jobs";
-import type { FactorMeta, FactorTestReport, ResearchSpec } from "@/lib/types";
+import type {
+  FactorMeta,
+  FactorParam,
+  FactorTemplate,
+  FactorTestReport,
+  ResearchSpec,
+} from "@/lib/types";
 import { recentRange } from "@/lib/dates";
 import {
   PageHeader,
@@ -18,8 +24,156 @@ import {
   SkeletonLines,
 } from "@/components/ui";
 
+/**
+ * 因子研究页。
+ *
+ * 参数化（2026-10 后端能力）之后，这个页面的诚实性要求变了：参数（窗口 / 方向）**可以改**，
+ * 但改的方式是「从模板新建一个参数化因子」—— 参数写进因子名，名字即身份。所以本页要
+ * ① 说清「改参数 = 新身份，旧因子与既有策略不变义」；② 把每行的真实参数摆出来；
+ * ③ 给一个受控的新建表单（范围来自 param_specs，越界由后端 422 拒绝，界面不静默纠正）。
+ */
+
+/** 方向枚举的中文说法：界面上不暴露 higher_is_better 这种原始值。 */
+const DIRECTION_TEXT: Record<string, string> = {
+  higher_is_better: "越高越好",
+  lower_is_better: "越低越好",
+};
+
+/** 参数原始值 → 展示值（方向枚举翻译成中文，其余原样；缺值退回模板默认值）。 */
+function paramValueText(spec: FactorParam, raw: number | string | undefined | null): string {
+  const value = raw === undefined || raw === null ? spec.default : raw;
+  if (typeof value === "string" && DIRECTION_TEXT[value]) return DIRECTION_TEXT[value];
+  return String(value);
+}
+
+/**
+ * 参数原始值 → **写进名字里的字面值**（整数写数字、枚举写 higher_is_better）。
+ *
+ * 与 paramValueText 分开的原因：名字是引擎键，必须原样；中文只用于给人看的文案。
+ */
+function paramRawText(spec: FactorParam, raw: number | string | undefined | null): string {
+  const value = raw === undefined || raw === null ? spec.default : raw;
+  return String(value);
+}
+
+/** 参数允许范围 / 枚举文案：展开行与新建表单共用一份，避免两处说法分叉。 */
+function paramRangeText(spec: FactorParam): string {
+  if (spec.kind === "int") {
+    const { minimum: min, maximum: max } = spec;
+    if (min !== undefined && min !== null && max !== undefined && max !== null) {
+      return `${min} ~ ${max} 的整数`;
+    }
+    return "整数";
+  }
+  const choices = spec.choices ?? [];
+  if (choices.length === 0) return "受控枚举";
+  return choices.map((c) => DIRECTION_TEXT[c] ?? c).join(" / ");
+}
+
+/** 单个参数的「标签 + 值」片段；方向这类不重复写标签（值本身已经是中文说法）。 */
+function paramPartText(spec: FactorParam, raw: number | string | undefined | null): string {
+  const value = paramValueText(spec, raw);
+  return spec.name === "direction" ? value : `${spec.label} ${value}`;
+}
+
+/**
+ * 目录里的「参数」摘要：`窗口 60 · 越高越好`。
+ *
+ * 没有 int 参数的因子是逐日时点值（如股息率），补一句「时点值（无窗口）」——
+ * 否则「没有窗口」和「窗口是 0」在界面上分不出来。
+ */
+function paramSummary(f: FactorMeta): string {
+  const specs = f.param_specs ?? [];
+  if (specs.length === 0) return f.resolvable === false ? "无参数声明" : "无参数";
+  const params = f.params ?? {};
+  const parts = specs.map((s) => paramPartText(s, params[s.name]));
+  if (!specs.some((s) => s.kind === "int")) parts.unshift("时点值（无窗口）");
+  return parts.join(" · ");
+}
+
+/**
+ * 来源文案。
+ *
+ * 为什么先判 resolvable：库里算不出来的历史手登记行，`source` 只是 DB 默认值 builtin，
+ * 直接读它会把它说成「内置实例」——那是假话。
+ */
+function sourceText(f: FactorMeta): string {
+  if (f.resolvable === false) return "历史手工登记行";
+  return f.source === "custom" ? "目录里的参数化实例" : "内置实例";
+}
+
+/** 界面显示名：优先后端给的中文名（含参数），没有才退回引擎键。 */
+function factorLabel(f: FactorMeta): string {
+  return f.label || f.name;
+}
+
+/** 新建表单初值：模板默认值，并以 param_specs 的 default 兜底（defaults 缺项也不空着）。 */
+function defaultsOf(t: FactorTemplate): Record<string, number | string> {
+  const out: Record<string, number | string> = {};
+  for (const s of t.param_specs) out[s.name] = t.defaults[s.name] ?? s.default;
+  return out;
+}
+
+/**
+ * 预览因子键：严格按 param_specs 的顺序拼 `模板名(参数=值,...)`（方向天然在最后）。
+ *
+ * 与后端 canonical_key 同一套形状 —— 预览错了就等于骗人，所以这里不做任何本地化/重排。
+ */
+function previewKey(t: FactorTemplate, values: Record<string, number | string>): string {
+  const args = t.param_specs.map((s) => `${s.name}=${paramRawText(s, values[s.name])}`);
+  return `${t.name}(${args.join(",")})`;
+}
+
+/** 预览中文名：镜像后端 _default_label（非方向参数用「、」，方向用「，」接在最后）。 */
+function previewLabel(t: FactorTemplate, values: Record<string, number | string>): string {
+  const parts: string[] = [];
+  let direction = "";
+  for (const s of t.param_specs) {
+    const value = paramValueText(s, values[s.name]);
+    if (s.name === "direction") direction = value;
+    else parts.push(`${s.label} ${value}`);
+  }
+  const inner = [parts.join("、"), direction].filter(Boolean).join("，");
+  return `${t.label}（${inner}）`;
+}
+
+/**
+ * 模板公式里的 `{参数}` 占位符按**当前表单值**渲染（镜像后端 _render）。
+ *
+ * 为什么不能在预览里直接摆模板原文：模板公式写的是 `close / close.shift({window}) - 1`，
+ * 而真实因子的公式是 `…shift(90)…` —— 摆原文会让预览和创建后的口径看起来不一致。
+ */
+function renderFormula(t: FactorTemplate, values: Record<string, number | string>): string {
+  return t.formula.replace(/\{(\w+)\}/g, (raw, key: string) => {
+    const spec = t.param_specs.find((s) => s.name === key);
+    return spec ? paramRawText(spec, values[key]) : raw;
+  });
+}
+
+/**
+ * 从 lib/api 抛出的错误里取出后端的 `detail` 原文。
+ *
+ * 为什么：apiPost 的报错是 `POST /factors → 422: {"detail":"…"}` 整串文本，而 422 的 detail
+ * 已经是给人看的中文（含允许范围、已有重名）—— 必须原样转述；界面自己再写一遍错误文案，
+ * 就会和后端的受控范围说法分叉。
+ */
+function apiDetail(e: unknown): string {
+  const raw = e instanceof Error ? e.message : String(e);
+  const start = raw.indexOf("{");
+  if (start >= 0) {
+    try {
+      const body = JSON.parse(raw.slice(start)) as { detail?: unknown };
+      if (typeof body.detail === "string" && body.detail) return body.detail;
+    } catch {
+      /* 响应体不是 JSON（如 500 的纯文本）：退回整串信息，至少不丢状态码 */
+    }
+  }
+  return raw;
+}
+
 export default function FactorsPage() {
   const [factors, setFactors] = useState<FactorMeta[]>([]);
+  const [templates, setTemplates] = useState<FactorTemplate[]>([]);
   const [loading, setLoading] = useState(true);
   const [checked, setChecked] = useState<Set<string>>(new Set());
   const [expanded, setExpanded] = useState<Set<string>>(new Set());
@@ -31,6 +185,26 @@ export default function FactorsPage() {
   const [current, setCurrent] = useState<{ idx: number; total: number; name: string } | null>(null);
   const [jobId, setJobId] = useState("");
   const [error, setError] = useState("");
+  /** 目录级成功提示（停用 / 启用）。 */
+  const [notice, setNotice] = useState("");
+
+  // 新建参数化因子表单
+  const [tplName, setTplName] = useState("");
+  const [paramValues, setParamValues] = useState<Record<string, number | string>>({});
+  const [creating, setCreating] = useState(false);
+  const [created, setCreated] = useState<{ name: string; label?: string } | null>(null);
+  const [createErr, setCreateErr] = useState("");
+  /** 模板清单是否还在加载：与目录分开，避免「还没加载完」被说成「没加载出来」。 */
+  const [tplLoading, setTplLoading] = useState(true);
+  /** 正在切换开关的因子名（只禁用那一行，不冻结全表）。 */
+  const [toggling, setToggling] = useState("");
+
+  /** 只刷新目录列表：不动勾选 / 展开状态（新建或停用后刷新不该清掉用户的选择）。 */
+  const refresh = useCallback(async () => {
+    const list = await apiGet<FactorMeta[]>("/factors");
+    setFactors(list);
+    return list;
+  }, []);
 
   useEffect(() => {
     let alive = true;
@@ -43,8 +217,22 @@ export default function FactorsPage() {
         );
         setChecked(new Set(picks));
       })
-      .catch((e: Error) => setError(e.message))
+      .catch((e: Error) => alive && setError(e.message))
       .finally(() => alive && setLoading(false));
+    // 模板清单单独取：它挂了只影响「新建参数化因子」卡片，不该把整个目录一起变成错误页
+    apiGet<FactorTemplate[]>("/factors/templates")
+      .then((tpls) => {
+        if (!alive) return;
+        setTemplates(tpls);
+        // 默认落在动量模板（最常见的例子）上，没有就取第一个
+        const t = tpls.find((x) => x.name === "momentum") ?? tpls[0];
+        if (t) {
+          setTplName(t.name);
+          setParamValues(defaultsOf(t));
+        }
+      })
+      .catch((e: Error) => alive && setCreateErr(e.message))
+      .finally(() => alive && setTplLoading(false));
     const { start: s, end: e } = recentRange();
     setStart(s);
     setEnd(e);
@@ -71,6 +259,60 @@ export default function FactorsPage() {
     });
   }
 
+  function pickTemplate(name: string) {
+    setTplName(name);
+    setCreateErr("");
+    setCreated(null);
+    const t = templates.find((x) => x.name === name);
+    setParamValues(t ? defaultsOf(t) : {});
+  }
+
+  function setParam(name: string, value: number | string) {
+    setParamValues((prev) => ({ ...prev, [name]: value }));
+  }
+
+  async function createFactor() {
+    const tpl = templates.find((x) => x.name === tplName);
+    if (!tpl) {
+      setCreateErr("请先选择一个模板");
+      return;
+    }
+    setCreating(true);
+    setCreateErr("");
+    setCreated(null);
+    try {
+      // 参数值原样提交（整数就是数字/数字串，枚举就是原始值）：受控校验只由后端做，
+      // 越界时转述 422 的 detail，界面不自己截断也不自己改写错误
+      const row = await apiPost<FactorMeta>("/factors", { template: tpl.name, params: paramValues });
+      setCreated({ name: row.name, label: row.label });
+      await refresh();
+    } catch (e) {
+      setCreateErr(apiDetail(e));
+    } finally {
+      setCreating(false);
+    }
+  }
+
+  async function toggleEnabled(f: FactorMeta) {
+    setToggling(f.name);
+    setNotice("");
+    setError("");
+    try {
+      const row = await apiPatch<FactorMeta>("/factors", { name: f.name, enabled: !f.enabled });
+      setNotice(
+        row.enabled
+          ? `因子 ${row.name} 已启用，重新出现在选择列表里。`
+          : `因子 ${row.name} 已停用：它仍留在目录里（既有策略 / 归档仍按它的名字解析），只是不再出现在选择列表里。`,
+      );
+      // 停用后照样刷新而不是本地隐藏 —— 停用的行必须还在目录里看得见
+      await refresh();
+    } catch (e) {
+      setError(apiDetail(e));
+    } finally {
+      setToggling("");
+    }
+  }
+
   async function run() {
     const names = factors.map((f) => f.name).filter((n) => checked.has(n));
     if (names.length === 0) {
@@ -119,6 +361,9 @@ export default function FactorsPage() {
   const reportNames = Object.keys(reports);
   const progressPct = selectedCount === 0 ? 0 : Math.round((processed / selectedCount) * 100);
 
+  const tpl = templates.find((x) => x.name === tplName) ?? null;
+  const tplSpecs = tpl?.param_specs ?? [];
+
   return (
     <>
       <PageHeader
@@ -132,6 +377,7 @@ export default function FactorsPage() {
           <pre style={{ margin: 0, whiteSpace: "pre-line", font: "inherit" }}>{error}</pre>
         </Banner>
       ) : null}
+      {notice && !running ? <Banner tone="info">{notice}</Banner> : null}
 
       <Card
         title="因子目录"
@@ -140,6 +386,18 @@ export default function FactorsPage() {
         tools={<Pill tone="violet">已选 {selectedCount} 个</Pill>}
         flush
       >
+        {/* 目录的性质说明：放在 loading 分支之外，加载中也能看到（也是 SSR 可断言的静态文案）。
+            参数化之后这里必须说清新分工：口径文案仍以代码为准，参数则靠「新建参数化因子」来改。
+            overflowWrap：示例键里没有空格，窄屏必须能断行，否则整页会横向溢出。 */}
+        <div className="hint" style={{ padding: "10px 14px 0", overflowWrap: "anywhere" }}>
+          目录是代码注册表（<span className="mono">quant/factors.py</span>）的<b>投影</b>：
+          口径文案（描述 / 公式 / 方向 / 回看）由引擎决定并自动同步（手改会在下次读取时被纠正回代码文本）。
+          <b>参数（窗口、方向）可以改</b>，改的方式是「从模板新建一个参数化因子」——
+          参数写进因子的名字里（如 <span className="mono">momentum(window=90,direction=higher_is_better)</span>），
+          所以新因子是一个<b>新身份</b>：旧因子、既有策略与归档都按各自名字里的参数计算，
+          <b>不会变义</b>。参数只在模板给定的受控范围内可选 / 可填，<b>越界会被后端拒绝</b>（不会静默截断成边界值）。
+          依赖列（<span className="mono">requires</span>）仍不可改 —— 它是「引擎能不能算」的事实，不是配置。
+        </div>
         {loading ? (
           <div style={{ padding: 18 }}>
             <SkeletonLines n={7} />
@@ -158,9 +416,11 @@ export default function FactorsPage() {
                   <tr>
                     <th style={{ width: 44 }}></th>
                     <th>因子</th>
+                    <th>参数</th>
                     <th>回看</th>
                     <th>方向</th>
                     <th>简介（用法 / 何时有效）</th>
+                    <th style={{ width: 96 }}>操作</th>
                   </tr>
                 </thead>
                 <tbody>
@@ -170,8 +430,10 @@ export default function FactorsPage() {
                       factor={f}
                       checked={checked.has(f.name)}
                       expanded={expanded.has(f.name)}
+                      toggling={toggling === f.name}
                       onToggleCheck={() => toggleCheck(f.name)}
                       onToggleExpand={() => toggleExpand(f.name)}
+                      onToggleEnabled={() => void toggleEnabled(f)}
                     />
                   ))}
                 </tbody>
@@ -184,6 +446,139 @@ export default function FactorsPage() {
         )}
       </Card>
 
+      <Card
+        icon="plus"
+        title="新建参数化因子"
+        sub="参数写进名字里 —— 新因子是一个新身份，旧因子与既有策略不变义"
+        tools={creating ? <Pill tone="accent" icon="spinner">创建中</Pill> : undefined}
+      >
+        {tplLoading ? (
+          <SkeletonLines n={3} />
+        ) : templates.length === 0 ? (
+          <div className="stack" style={{ gap: 10 }}>
+            <div className="hint">
+              模板清单没加载出来（<span className="mono">GET /api/factors/templates</span> 未返回模板），
+              所以暂时无法新建参数化因子；目录本身不受影响。
+            </div>
+            {createErr ? <Banner tone="error">{createErr}</Banner> : null}
+          </div>
+        ) : (
+          <div className="stack" style={{ gap: 12 }}>
+            <div className="form-grid">
+              <Field
+                label="模板"
+                className="field--wide"
+                htmlFor="factor-new-template"
+                hint="只能从代码注册的模板派生：引擎算不出来的参数组合在这里根本不会出现"
+              >
+                <select
+                  id="factor-new-template"
+                  className="input"
+                  value={tplName}
+                  onChange={(e) => pickTemplate(e.target.value)}
+                >
+                  <option value="">选择模板…</option>
+                  {templates.map((t) => (
+                    <option key={t.name} value={t.name}>
+                      {t.label}（{t.name}
+                      {t.instances.length > 0
+                        ? `，已有 ${t.instances.join(" / ")}`
+                        : "，还没有实例"}
+                      ）
+                    </option>
+                  ))}
+                </select>
+              </Field>
+
+              {/* 受控表单：参数从模板 param_specs 来，顺序也照它（方向恒在最后） */}
+              {tplSpecs.map((s) =>
+                s.kind === "int" ? (
+                  <Field
+                    key={s.name}
+                    label={`${s.label}（${s.name}）`}
+                    htmlFor={`factor-new-${s.name}`}
+                    hint={`${paramRangeText(s)}；越界会被后端拒绝，不会截断成边界值`}
+                  >
+                    <input
+                      id={`factor-new-${s.name}`}
+                      className="input"
+                      type="number"
+                      min={s.minimum ?? undefined}
+                      max={s.maximum ?? undefined}
+                      step={1}
+                      value={String(paramValues[s.name] ?? "")}
+                      onChange={(e) => setParam(s.name, e.target.value)}
+                    />
+                  </Field>
+                ) : (
+                  <Field
+                    key={s.name}
+                    label={`${s.label}（${s.name}）`}
+                    htmlFor={`factor-new-${s.name}`}
+                    hint={paramRangeText(s)}
+                  >
+                    <select
+                      id={`factor-new-${s.name}`}
+                      className="input"
+                      value={String(paramValues[s.name] ?? s.default)}
+                      onChange={(e) => setParam(s.name, e.target.value)}
+                    >
+                      {(s.choices ?? []).map((c) => (
+                        <option key={c} value={c}>
+                          {DIRECTION_TEXT[c] ?? c}
+                        </option>
+                      ))}
+                    </select>
+                  </Field>
+                ),
+              )}
+
+              <Btn
+                variant="primary"
+                icon="plus"
+                loading={creating}
+                disabled={creating || !tpl}
+                onClick={createFactor}
+              >
+                新建参数化因子
+              </Btn>
+            </div>
+
+            {tpl ? (
+              /* overflowWrap：预览键是长且无空格的引擎键，窄屏要能断行 */
+              <div className="stack" style={{ gap: 4, overflowWrap: "anywhere" }}>
+                <div className="field__label">创建预览</div>
+                <div className="hint">
+                  因子键：<b className="mono">{previewKey(tpl, paramValues)}</b>
+                  {" "}（参数顺序与模板一致，方向恒在最后；这个键就是身份）
+                </div>
+                <div className="hint">
+                  中文名：{previewLabel(tpl, paramValues)}
+                  {" "}· 公式 <span className="mono">{renderFormula(tpl, paramValues)}</span>
+                </div>
+                <div className="hint">
+                  中文名按引擎的通用规则预览（量比这类有定制命名的模板，创建后以引擎返回的名字为准）。
+                </div>
+              </div>
+            ) : null}
+
+            {created ? (
+              <Banner tone="info">
+                已创建因子 <b className="mono">{created.name}</b>
+                {created.label ? <>（{created.label}）</> : null}：参数已经写进名字里，
+                这是一个新身份 —— <b>旧因子与既有策略不变义</b>。
+              </Banner>
+            ) : null}
+            {createErr ? <Banner tone="error">{createErr}</Banner> : null}
+
+            <div className="hint">
+              参数相同不会重复创建：同一模板、同一组参数只对应一个因子键，重复提交会收到后端的重名提示。
+              要换参数就再建一个（新键），不要指望改旧键 —— 旧键被改了，引用它的策略与归档就会变义。
+            </div>
+          </div>
+        )}
+      </Card>
+
       <Card title="运行单因子测试" icon="play" tools={running ? <Pill tone="accent" icon="spinner">执行中</Pill> : undefined}>
         <div className="form-grid">
           <Field label="开始日期">
@@ -238,8 +633,16 @@ export default function FactorsPage() {
           <Card
             key={name}
             icon="chartLine"
-            title={name}
-            sub={meta?.brief}
+            title={meta ? factorLabel(meta) : name}
+            sub={
+              meta && meta.label && meta.label !== name ? (
+                <span style={{ overflowWrap: "anywhere" }}>
+                  <span className="mono">{name}</span> · {meta.brief}
+                </span>
+              ) : (
+                meta?.brief
+              )
+            }
             tools={
               <Pill tone="pos" icon="check">
                 已完成
@@ -258,13 +661,23 @@ function FactorRow(props: {
   factor: FactorMeta;
   checked: boolean;
   expanded: boolean;
+  toggling: boolean;
   onToggleCheck: () => void;
   onToggleExpand: () => void;
+  onToggleEnabled: () => void;
 }) {
   const { factor: f } = props;
+  const label = factorLabel(f);
+  // 开关只对「目录里创建的参数化实例」开放：内置实例的开关由代码决定（后端会 422），
+  // 算不出来的历史行也不给开关（后端拒绝，且开关本来就没有意义）
+  const canToggle = f.source === "custom" && f.resolvable !== false;
+  const high = f.direction === "higher_is_better";
   return (
     <>
-      <tr style={{ cursor: "pointer" }} onClick={props.onToggleExpand}>
+      <tr
+        style={{ cursor: "pointer", opacity: f.enabled === false ? 0.55 : 1 }}
+        onClick={props.onToggleExpand}
+      >
         <td onClick={(e) => e.stopPropagation()}>
           <label className="check check--cell" title={`选择因子 ${f.name}`}>
             <input
@@ -276,29 +689,128 @@ function FactorRow(props: {
           </label>
         </td>
         <td className="cell-strong">
-          <span className="mono">{f.name}</span>
+          {label}
+          {/* 名字就是身份：中文名旁边的引擎键必须看得见（含参数，如 momentum(window=90,…)） */}
+          {f.label && f.label !== f.name ? (
+            <span
+              className="hint mono cell-hint"
+              style={{ fontWeight: 400, overflowWrap: "anywhere" }}
+            >
+              {f.name}
+            </span>
+          ) : null}
+          {f.enabled === false ? <> <Pill tone="warn">已停用</Pill></> : null}
+          {f.resolvable === false ? <> <Pill tone="neg">引擎算不出来</Pill></> : null}
         </td>
+        <td className="hint">{paramSummary(f)}</td>
         <td>
           <span className="tag tag--mono">{f.lookback} 日</span>
         </td>
         <td>
-          <Pill tone={f.direction === "higher_is_better" ? "accent" : "violet"}>
-            {f.direction === "higher_is_better" ? "高为好" : "低为好"}
-          </Pill>
+          {/* 算不出来的历史行没有可信方向（direction 只是 DB 默认值），不摆一个假的方向 */}
+          {f.resolvable === false ? (
+            <span className="hint">—</span>
+          ) : (
+            <Pill tone={high ? "accent" : "violet"}>{high ? "越高越好" : "越低越好"}</Pill>
+          )}
         </td>
         <td className="hint">{f.brief ?? f.description}</td>
+        <td onClick={(e) => e.stopPropagation()}>
+          {canToggle ? (
+            <Btn
+              disabled={props.toggling}
+              loading={props.toggling}
+              onClick={props.onToggleEnabled}
+              title={f.enabled === false ? "启用后重新出现在选择列表里" : "停用只是不出现在选择列表里，历史解析不变"}
+            >
+              {f.enabled === false ? "启用" : "停用"}
+            </Btn>
+          ) : (
+            <Btn
+              disabled
+              title={
+                f.resolvable === false
+                  ? "引擎算不出来（历史手工登记行），不能启用或停用"
+                  : "内置实例的开关由代码决定，不能在目录里改；要不同参数请从模板新建参数化因子"
+              }
+            >
+              停用
+            </Btn>
+          )}
+        </td>
       </tr>
       {props.expanded ? (
         <tr className="expand-cell">
-          <td colSpan={5}>
-            <div>
-              <b className="mono">{f.name}</b> · {f.description}
-              <div className="hint" style={{ marginTop: 6 }}>
-                公式：<span className="mono">{f.formula}</span>；回看 {f.lookback} 个交易日；频率 {f.frequency}；
-                方向：
-                {f.direction === "higher_is_better" ? "因子值越高得分越高" : "因子值越低得分越高（引擎自动反向）"}
+          <td colSpan={7}>
+            <div className="stack" style={{ gap: 8 }}>
+              {/* 展开行里也会出现长参数键，窄屏同样要能断行 */}
+              <div style={{ overflowWrap: "anywhere" }}>
+                <b className="mono">{f.name}</b> · {f.description}
               </div>
-              {f.brief ? <div className="hint" style={{ marginTop: 6 }}>{f.brief}</div> : null}
+
+              <div className="stack" style={{ gap: 3 }}>
+                <div className="field__label">参数（写进名字里的身份）</div>
+                {(f.param_specs ?? []).length > 0 ? (
+                  (f.param_specs ?? []).map((s) => (
+                    <div key={s.name} className="row" style={{ gap: 8, flexWrap: "wrap" }}>
+                      <span className="mono" style={{ minWidth: 72 }}>{s.name}</span>
+                      <b>{paramValueText(s, (f.params ?? {})[s.name])}</b>
+                      {/* 枚举参数的 note 往往已把可选值抄了一遍（如方向），就不再重复一次 */}
+                      <span className="hint">
+                        {s.kind === "int"
+                          ? `允许 ${paramRangeText(s)}${s.note ? ` · ${s.note}` : ""}`
+                          : `可选 ${paramRangeText(s)}${
+                              s.note && !s.note.includes(paramRangeText(s)) ? ` · ${s.note}` : ""
+                            }`}
+                      </span>
+                    </div>
+                  ))
+                ) : (
+                  <div className="hint">
+                    该因子没有声明可编辑参数{f.resolvable === false ? "（历史手工登记行）" : "（时点值口径，无窗口）"}。
+                  </div>
+                )}
+              </div>
+
+              <div className="hint">
+                公式：<span className="mono">{f.formula}</span>；频率 {f.frequency}；回看 {f.lookback} 个交易日；
+                方向：
+                {f.resolvable === false
+                  ? "未知（引擎算不出来）"
+                  : high
+                    ? "因子值越高得分越高"
+                    : "因子值越低得分越高（引擎自动反向）"}
+              </div>
+              <div className="hint">
+                依赖列：
+                {f.requires && f.requires.length > 0 ? (
+                  <span className="mono">{f.requires.join(" / ")}</span>
+                ) : (
+                  "无"
+                )}
+                （引擎能不能算的事实，不可改）
+              </div>
+              <div className="row" style={{ gap: 8, flexWrap: "wrap" }}>
+                <Pill>{sourceText(f)}</Pill>
+                {f.template ? (
+                  <span className="hint">
+                    模板 <span className="mono">{f.template}</span>
+                  </span>
+                ) : null}
+                <Pill tone={f.enabled === false ? "warn" : "pos"}>
+                  {f.enabled === false ? "已停用" : "启用中"}
+                </Pill>
+                {f.enabled === false ? (
+                  <span className="hint">既有策略 / 归档仍按它的名字解析，停用只是不出现在选择列表里。</span>
+                ) : null}
+              </div>
+              {f.resolvable === false ? (
+                <Banner tone="warn">
+                  引擎算不出来（历史手工登记行），引用时会报错：这不是「配置不一致」，
+                  而是代码注册表里没有能解析它的模板 / 参数。
+                </Banner>
+              ) : null}
+              {f.brief ? <div className="hint">{f.brief}</div> : null}
             </div>
           </td>
         </tr>
@@ -365,4 +877,4 @@ function ReportView({ report }: { report: FactorTestReport }) {
       </div>
     </div>
   );
-}
+}

frontend/web/app/fields/page.tsx

@@ -0,0 +1,435 @@
+"use client";
+
+/**
+ * 字段库（/fields）—— 过滤条件可用字段的目录与维护页。
+ *
+ * 解决三个问题（用户 2026-10 反馈）：
+ * 1. 过滤条件的字段此前要**手填**（dv_ratio / static.industry …），看不到含义、写错不报错；
+ *    现在字段有中文名 + 口径说明 + 单位 + 类型，条件编辑器里是分组下拉。
+ * 2. 字段库可增减、可编辑：改中文名/含义/单位/分组，停用不用的，新增少用但引擎支持的。
+ * 3. 说清「打分因子 vs 过滤条件」的关系 —— 见下方说明卡。
+ *
+ * 诚实性约束：能加什么由**引擎**决定（后端校验）。加一个引擎算不出来的字段，条件会
+ * 永远不通过 —— 所以这里只允许从「引擎支持但尚未进库」的清单里挑，不允许手填乱造。
+ */
+import { useCallback, useEffect, useState } from "react";
+import Link from "next/link";
+import { apiDelete, apiGet, apiPost, apiPut } from "@/lib/api";
+import type { ConditionField, ConditionFieldOption } from "@/lib/types";
+import { factorOf } from "@/lib/units";
+import { Banner, Btn, Card, Empty, Field, Loading, PageHeader, Pill } from "@/components/ui";
+
+/** 编辑中的行（null=未编辑）。 */
+type Draft = {
+  label: string;
+  description: string;
+  unit: string;
+  group_name: string;
+  enabled: boolean;
+};
+
+const KIND_LABEL: Record<ConditionField["kind"], string> = { num: "数值", str: "文本" };
+
+/** 单位选择器：**只能从注册表给的阶梯里选**（万元 ⇄ 亿元 这类固定换算），不给自由文本。
+ *
+ * 单位分两层：基准单位（引擎存储/比较用，改不了）与界面单位（这里选的，只影响输入/显示）。
+ * 选成亿元后，策略表单里按亿元输入、提交时 ×10000 存成万元 —— 引擎比较口径不变，
+ * 所以改单位不会让任何历史策略变义。只有一个单位的字段直接显示出来（没什么可选的）。
+ */
+function UnitSelect({
+  field,
+  value,
+  onChange,
+}: {
+  field: ConditionField;
+  value: string;
+  onChange: (unit: string) => void;
+}) {
+  const units = field.units ?? [];
+  const base = field.base_unit || field.unit;
+  if (units.length < 2) {
+    return (
+      <span className="hint" title={`引擎按基准单位「${base}」存储与比较`}>
+        {value || base}
+      </span>
+    );
+  }
+  return (
+    <div className="cell-stack" style={{ gap: 2 }}>
+      <select
+        className="input"
+        style={{ width: 88 }}
+        aria-label={`${field.label} 的界面单位`}
+        value={value}
+        onChange={(e) => onChange(e.target.value)}
+      >
+        {units.map((u) => (
+          <option key={u.unit} value={u.unit}>
+            {u.unit}
+          </option>
+        ))}
+      </select>
+      <span className="hint cell-hint">
+        1 {value} = {factorOf(units, value)} {base}
+      </span>
+    </div>
+  );
+}
+
+export default function FieldsPage() {
+  const [rows, setRows] = useState<ConditionField[] | null>(null);
+  const [options, setOptions] = useState<ConditionFieldOption[]>([]);
+  const [err, setErr] = useState("");
+  const [msg, setMsg] = useState("");
+  const [busy, setBusy] = useState(false);
+
+  // 行内编辑状态
+  const [editName, setEditName] = useState<string | null>(null);
+  const [draft, setDraft] = useState<Draft | null>(null);
+
+  // 新增表单
+  const [addName, setAddName] = useState("");
+  const [addLabel, setAddLabel] = useState("");
+  const [addDesc, setAddDesc] = useState("");
+  const [addUnit, setAddUnit] = useState("");
+
+  const load = useCallback(async () => {
+    try {
+      const [list, avail] = await Promise.all([
+        apiGet<ConditionField[]>("/condition-fields"),
+        apiGet<ConditionFieldOption[]>("/condition-fields/available"),
+      ]);
+      setRows(list);
+      setOptions(avail);
+    } catch (e) {
+      setErr((e as Error).message);
+    }
+  }, []);
+
+  useEffect(() => {
+    void load();
+  }, [load]);
+
+  function startEdit(f: ConditionField) {
+    setErr("");
+    setMsg("");
+    setEditName(f.name);
+    setDraft({
+      label: f.label,
+      description: f.description,
+      unit: f.unit,
+      group_name: f.group_name,
+      enabled: f.enabled,
+    });
+  }
+
+  async function saveEdit() {
+    if (!editName || !draft) return;
+    setBusy(true);
+    setErr("");
+    try {
+      await apiPut<ConditionField>(`/condition-fields/${encodeURIComponent(editName)}`, draft);
+      setMsg(`已保存字段「${draft.label}」`);
+      setEditName(null);
+      setDraft(null);
+      await load();
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  /** 停用/启用：内置字段不能删，只能停用（删了下次读取会自动补回）。 */
+  async function toggleEnabled(f: ConditionField) {
+    setBusy(true);
+    setErr("");
+    try {
+      await apiPut<ConditionField>(`/condition-fields/${encodeURIComponent(f.name)}`, {
+        enabled: !f.enabled,
+      });
+      setMsg(`字段「${f.label}」已${f.enabled ? "停用（条件编辑器里不再出现）" : "启用"}`);
+      await load();
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  async function remove(f: ConditionField) {
+    if (!window.confirm(`删除自定义字段「${f.label}」（${f.name}）？删掉后可重新从「新增字段」加回来。`)) {
+      return;
+    }
+    setBusy(true);
+    setErr("");
+    try {
+      await apiDelete(`/condition-fields/${encodeURIComponent(f.name)}`);
+      setMsg(`已删除自定义字段「${f.label}」`);
+      await load();
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  function pickOption(name: string) {
+    setAddName(name);
+    const o = options.find((x) => x.name === name);
+    if (o) {
+      setAddLabel(o.label);
+      setAddDesc(o.description);
+      setAddUnit(o.unit);
+    }
+  }
+
+  async function addField() {
+    if (!addName) return;
+    setBusy(true);
+    setErr("");
+    setMsg("");
+    try {
+      const created = await apiPost<ConditionField>("/condition-fields", {
+        name: addName,
+        label: addLabel,
+        description: addDesc,
+        unit: addUnit,
+      });
+      setMsg(`已新增字段「${created.label}」（${created.name}），现在可以在过滤条件里选它`);
+      setAddName("");
+      setAddLabel("");
+      setAddDesc("");
+      setAddUnit("");
+      await load();
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  // 分组展示：后端已按 sort_order 排序，这里只做「保持首次出现顺序」的分组
+  const groups: { name: string; items: ConditionField[] }[] = [];
+  for (const f of rows ?? []) {
+    const g = groups.find((x) => x.name === f.group_name);
+    if (g) g.items.push(f);
+    else groups.push({ name: f.group_name, items: [f] });
+  }
+  const groupNames = groups.map((g) => g.name);
+
+  return (
+    <>
+      <PageHeader
+        title="字段库"
+        sub="过滤条件能用的字段目录：中文名、口径、单位都在这里定义。内置字段随引擎自动同步；中文名与含义可以改成你自己的说法，用不到的可以停用，少用的可以从「新增字段」加进来。"
+        actions={
+          <div className="row" style={{ gap: 8 }}>
+            <Link href="/strategies" className="btn"><span>去编辑选股策略</span></Link>
+          </div>
+        }
+      />
+
+      {err ? <Banner tone="error">{err}</Banner> : null}
+      {msg ? <Banner tone="info">{msg}</Banner> : null}
+
+      {/* 因子 vs 条件的关系（用户问题第 3 条） */}
+      <Card icon="info" title="打分因子 与 过滤条件 是什么关系？">
+        <div className="stack" style={{ gap: 10 }}>
+          <div>
+            <b>一句话：条件决定「有没有资格」，因子决定「谁排前面」。</b>
+            两者在选股流程里是<b>先后两步</b>，不是二选一。
+          </div>
+          <div className="chips">
+            <span className="chip"><b>1 股票池</b> 剔除 ST / 上市天数不足 / 非指数成分</span>
+            <span className="chip"><b>2 过滤条件</b> 全部 AND 通过才有资格（不排序）</span>
+            <span className="chip"><b>3 打分因子</b> 横截面 z-score 加权 → 复合分排序</span>
+            <span className="chip"><b>4 取 TopN</b> N 在回测组合里定，不在策略里</span>
+          </div>
+          <div className="hint">
+            <b>用你库里的策略举例（高股息 Top20）：</b>
+            条件 <code className="mono">dv_ratio ≤ 30</code> 先剔掉「股息率 &gt; 30% 的异常样本」
+            （多为一次性特别分红或股价暴跌，是典型的「高股息陷阱」）—— 这是<b>准入</b>；
+            因子 <code className="mono">dividend_yield</code> 给剩下的股票打分排序，
+            让股息率更高的排前面 —— 这是<b>优先级</b>。
+            同一个字段（比如股息率）既可以是条件也可以是因子：当条件用就是「筛掉」，当因子用就是「排序」。
+          </div>
+          <div className="hint">
+            另外两点容易混：<b>股票池</b>（剔 ST、上市天数、指数成分）也是过滤，但它属于策略的
+            「universe」，在条件之前执行；<b>取多少只（N）</b>不属于选股策略 ——
+            同一个策略配不同 N 是不同风险收益，所以它在「回测组合」里填。
+          </div>
+          <div className="hint">
+            <b>这里只列内置因子名</b>（如 <code className="mono">momentum_60</code>）。
+            自己新建的<b>参数化因子</b>（如 <code className="mono">momentum(window=90,direction=higher_is_better)</code>）
+            在<a href="/factors">因子研究</a>页管理，选股策略的条件字段下拉里会一并出现 ——
+            它们算的是同一个引擎字段，只是参数不同。
+          </div>
+        </div>
+      </Card>
+
+      {/* 新增字段 */}
+      <Card icon="plus" title="新增字段" sub="只能从「引擎支持但尚未进库」的字段里挑：加一个算不出来的字段，条件会永远不通过">
+        {options.length === 0 ? (
+          <div className="hint">没有可新增的字段了 —— 引擎支持且未进库的字段都已加入。</div>
+        ) : (
+          <div className="form-grid">
+            <Field label="字段" className="field--wide">
+              <select
+                className="input"
+                aria-label="可新增字段"
+                value={addName}
+                onChange={(e) => pickOption(e.target.value)}
+              >
+                <option value="">选择字段…</option>
+                {options.map((o) => (
+                  <option key={o.name} value={o.name}>
+                    {o.group_name} · {o.label}（{o.name}）
+                  </option>
+                ))}
+              </select>
+            </Field>
+            <Field label="中文名" hint="空则用默认">
+              <input className="input" value={addLabel} onChange={(e) => setAddLabel(e.target.value)} />
+            </Field>
+            <Field label="界面单位" hint="只能从引擎给定的单位里选">
+              {(() => {
+                const opt = options.find((o) => o.name === addName);
+                const units = opt?.units ?? [];
+                const base = opt?.unit ?? "";
+                if (units.length < 2) {
+                  return <span className="hint">{base || "—"}（该字段只有基准单位）</span>;
+                }
+                return (
+                  <select
+                    className="input"
+                    aria-label="新增字段的界面单位"
+                    value={addUnit}
+                    onChange={(e) => setAddUnit(e.target.value)}
+                  >
+                    {units.map((u) => (
+                      <option key={u.unit} value={u.unit}>
+                        {u.unit}（1 {u.unit} = {u.factor} {base}）
+                      </option>
+                    ))}
+                  </select>
+                );
+              })()}
+            </Field>
+            <Field label="含义 / 口径" className="field--wide" hint="写清口径，将来才看得懂">
+              <input
+                className="input"
+                value={addDesc}
+                onChange={(e) => setAddDesc(e.target.value)}
+                placeholder="例：总市值 = 总股本 × 收盘价（万元）"
+              />
+            </Field>
+            <Btn icon="plus" variant="primary" disabled={busy || !addName} onClick={addField}>
+              加入字段库
+            </Btn>
+          </div>
+        )}
+      </Card>
+
+      <Card icon="filter" title={`字段目录 · ${rows?.length ?? 0} 个`} tools={
+        <Btn icon="refresh" size="sm" onClick={() => void load()} disabled={busy}>刷新</Btn>
+      }>
+        {rows === null ? (
+          <Loading label="加载字段库…" />
+        ) : rows.length === 0 ? (
+          <Empty icon="filter" title="字段库为空" hint="刷新后会从引擎注册表自动补齐内置字段。" />
+        ) : (
+          <div className="stack" style={{ gap: 14 }}>
+            {groups.map((g) => (
+              <div key={g.name}>
+                <div className="form-section__title">{g.name} · {g.items.length}</div>
+                <div className="table-wrap">
+                  <table className="tbl">
+                    <thead>
+                      <tr>
+                        <th style={{ width: 150 }}>中文名</th>
+                        <th style={{ width: 190 }}>字段名</th>
+                        <th style={{ width: 96 }}>类型 / 单位</th>
+                        <th>含义 / 口径</th>
+                        <th style={{ width: 96 }}>来源</th>
+                        <th style={{ width: 170 }}>操作</th>
+                      </tr>
+                    </thead>
+                    <tbody>
+                      {g.items.map((f) =>
+                        editName === f.name && draft ? (
+                          <tr key={f.name} className="row-active">
+                            <td><input className="input" value={draft.label} onChange={(e) => setDraft({ ...draft, label: e.target.value })} /></td>
+                            <td className="cell-mono">{f.name}</td>
+                            <td>
+                              <UnitSelect
+                                field={f}
+                                value={draft.unit}
+                                onChange={(unit) => setDraft({ ...draft, unit })}
+                              />
+                            </td>
+                            <td>
+                              <input className="input" value={draft.description} onChange={(e) => setDraft({ ...draft, description: e.target.value })} />
+                            </td>
+                            <td><Pill>{f.source === "builtin" ? "内置" : "自定义"}</Pill></td>
+                            <td>
+                              <div className="row" style={{ gap: 6 }}>
+                                <Btn size="sm" variant="primary" disabled={busy} onClick={saveEdit}>保存</Btn>
+                                <Btn size="sm" disabled={busy} onClick={() => { setEditName(null); setDraft(null); }}>取消</Btn>
+                              </div>
+                            </td>
+                          </tr>
+                        ) : (
+                          <tr key={f.name} style={f.enabled ? undefined : { opacity: 0.55 }}>
+                            <td className="cell-strong">
+                              {f.label}
+                              {!f.enabled ? <> <Pill tone="warn">已停用</Pill></> : null}
+                            </td>
+                            <td className="cell-mono">{f.name}</td>
+                            <td>
+                              {KIND_LABEL[f.kind]}
+                              {f.unit ? (
+                                <span className="hint" style={{ marginLeft: 4 }}>
+                                  {f.unit}
+                                  {f.base_unit && f.unit !== f.base_unit ? (
+                                    <span title={`引擎按基准单位 ${f.base_unit} 存储与比较；界面按 ${factorOf(f.units, f.unit)} 倍换算`}>
+                                      （基准 {f.base_unit}，×{factorOf(f.units, f.unit)}）
+                                    </span>
+                                  ) : null}
+                                </span>
+                              ) : null}
+                            </td>
+                            <td>{f.description}</td>
+                            <td><Pill>{f.source === "builtin" ? "内置" : "自定义"}</Pill></td>
+                            <td>
+                              <div className="row" style={{ gap: 6 }}>
+                                <Btn size="sm" icon="edit" disabled={busy} onClick={() => startEdit(f)}>编辑</Btn>
+                                <Btn size="sm" disabled={busy} onClick={() => toggleEnabled(f)}>
+                                  {f.enabled ? "停用" : "启用"}
+                                </Btn>
+                                {f.source === "custom" ? (
+                                  <Btn size="sm" variant="danger" icon="trash" disabled={busy} onClick={() => remove(f)}>
+                                    删除
+                                  </Btn>
+                                ) : null}
+                              </div>
+                            </td>
+                          </tr>
+                        )
+                      )}
+                    </tbody>
+                  </table>
+                </div>
+              </div>
+            ))}
+            <div className="hint">
+              分组顺序与可用比较符由引擎类型决定：{groupNames.length} 个分组。文本字段只能「等于 / 不等于 / 属于 /
+              不属于」，数值字段才能比大小 —— 这样不会摆出「行业 &gt; 5」这种永远为假的选项。
+              内置字段不能删除（删掉下次读取会自动补回），不想看到就「停用」。
+            </div>
+          </div>
+        )}
+      </Card>
+    </>
+  );
+}

frontend/web/app/globals.css

@@ -708,11 +708,13 @@ input[type="date"].input {
 .factor-row {
   display: grid;
   /* 因子名列封顶 460px：再宽就是「momentum_60」配 1500px 下拉的失调（截图实测）。
-     权重列固定，操作列按内容。整行也限宽，避免在宽屏上拉成一条长线。 */
+     权重列固定，操作列按内容。整行也限宽，避免在宽屏上拉成一条长线。
+     start 对齐：因子列比别列高（下拉 + 口径/方向/简介两行说明），
+     居中会让权重框浮在说明旁边显得没对齐。 */
   grid-template-columns: minmax(150px, 460px) 118px auto;
-  align-items: center;
+  align-items: start;
   gap: var(--sp-2);
-  max-width: 720px;
+  max-width: 760px;
 }
 
 .factor-rows__head {
@@ -731,17 +733,69 @@ input[type="date"].input {
 .cond-rows {
   display: grid;
   gap: var(--sp-2);
-  max-width: 760px;
+  max-width: 940px;
 }
 
 .cond-rows__head,
 .cond-row {
   display: grid;
-  grid-template-columns: minmax(150px, 360px) 84px minmax(96px, 160px) auto;
-  align-items: center;
+  grid-template-columns: minmax(150px, 260px) 84px 110px minmax(120px, 190px) auto;
+  align-items: start;
   gap: var(--sp-2);
 }
 
+/* 单元格：下拉 + 该选项的口径说明（因子行与条件行共用 —— 选了就能看到含义，
+   不用切到「字段库」/「因子研究」页去查） */
+.cell-stack {
+  display: grid;
+  gap: 2px;
+  align-content: center;
+}
+
+.cell-hint {
+  font-size: var(--fs-xs);
+  line-height: 1.35;
+  display: block;
+}
+
+/* 取值单元格：输入框 + 右侧的**界面单位**后缀。存储值一律是基准单位，这里显示的是
+   字段库选的界面单位（如「亿元」），提交时按系数换算 —— 所以后缀必须始终可见，
+   否则用户会把「5 亿元」当成「5 万元」来读。 */
+.unit-input {
+  display: grid;
+  grid-template-columns: 1fr auto;
+  align-items: center;
+  gap: 4px;
+}
+
+.unit-suffix {
+  font-size: var(--fs-xs);
+  color: var(--text-3);
+  white-space: nowrap;
+}
+
+/* 因子 vs 条件 的关系说明卡（表单内固定展示） */
+.relation-note {
+  margin-top: 14px;
+  padding: 10px 12px;
+  border: 1px solid var(--line);
+  border-radius: var(--r-2);
+  background: var(--surface-2, transparent);
+  display: grid;
+  gap: 8px;
+}
+
+.relation-note__title {
+  font-weight: 600;
+  font-size: var(--fs-sm);
+}
+
+.relation-note__flow {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 6px;
+}
+
 .cond-rows__head {
   color: var(--text-3);
   font-size: var(--fs-xs);
@@ -2026,3 +2080,108 @@ button.chip:hover {
   background: var(--bg-2);
   color: var(--text-1);
 }
+
+/* ---------- 回测组合：选股策略多选卡片 ---------- */
+.strategy-pick {
+  display: grid;
+  grid-template-columns: repeat(auto-fill, minmax(260px, 1fr));
+  gap: var(--sp-2);
+}
+
+.strategy-pick__item {
+  display: grid;
+  grid-template-columns: auto 1fr;
+  grid-template-areas:
+    "check name"
+    "check meta"
+    "desc desc"
+    "factors factors";
+  gap: 2px var(--sp-2);
+  align-items: center;
+  padding: var(--sp-2) var(--sp-3);
+  border: 1px solid var(--line-strong);
+  border-radius: var(--r-sm);
+  background: var(--surface-2);
+  cursor: pointer;
+  transition: border-color 0.15s ease, background 0.15s ease;
+}
+
+.strategy-pick__item:hover {
+  border-color: rgba(150, 165, 195, 0.42);
+}
+
+.strategy-pick__item.is-on {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.strategy-pick__item input[type="checkbox"] {
+  grid-area: check;
+  width: 16px;
+  height: 16px;
+}
+
+.strategy-pick__name {
+  grid-area: name;
+  font-weight: 600;
+  color: var(--text-1);
+  font-size: var(--fs-sm);
+}
+
+.strategy-pick__meta {
+  grid-area: meta;
+  color: var(--text-3);
+  font-size: var(--fs-xs);
+}
+
+.strategy-pick__desc {
+  grid-area: desc;
+  color: var(--text-2);
+  font-size: var(--fs-xs);
+  line-height: 1.5;
+  margin-top: 4px;
+}
+
+.strategy-pick__factors {
+  grid-area: factors;
+  color: var(--violet);
+  font-size: var(--fs-xs);
+  margin-top: 2px;
+}
+
+/* ---------- 回测组合：已保存组合库 ---------- */
+/* 单列纵向列表（每行「摘要 + 操作」），与选股策略卡的网格区分：
+   组合条目信息更密（参数 chip + 说明 + 三个动作），横排比网格更好扫读。 */
+.combo-list {
+  display: flex;
+  flex-direction: column;
+  gap: var(--sp-2);
+}
+
+.combo-item {
+  display: flex;
+  flex-wrap: wrap;
+  gap: var(--sp-3);
+  align-items: center;
+  justify-content: space-between;
+  padding: var(--sp-2) var(--sp-3);
+  border: 1px solid var(--line-strong);
+  border-radius: var(--r-sm);
+  background: var(--surface-2);
+  transition: border-color 0.15s ease, background 0.15s ease;
+}
+
+.combo-item:hover {
+  border-color: rgba(150, 165, 195, 0.42);
+}
+
+/* 当前载入的组合：与 .strategy-pick__item.is-on 同一视觉语言（强调色描边） */
+.combo-item.is-on {
+  border-color: var(--accent);
+  background: var(--accent-soft);
+}
+
+.combo-item__main {
+  min-width: 0;
+  flex: 1 1 320px;
+}

frontend/web/app/selection/page.tsx

@@ -9,6 +9,7 @@ import { useEffect, useState } from "react";
 import { apiGet, apiPost } from "@/lib/api";
 import { SymbolLink } from "@/lib/symbols";
 import { waitJob } from "@/lib/jobs";
+import { factorOptionLabel, pickableFactors } from "@/lib/factors";
 import type {
   FactorMeta,
   SelectionCondition,
@@ -87,7 +88,8 @@ export default function SelectionPage() {
   useEffect(() => {
     let alive = true;
     apiGet<FactorMeta[]>("/factors")
-      .then((list) => alive && list.length > 0 && setFactors(list))
+      // 停用/算不出来的因子不摆进候选（停用仍可被既有策略解析，只是不该再被选中）
+      .then((list) => alive && list.length > 0 && setFactors(pickableFactors(list)))
       .catch((e: Error) => alive && setError(e.message));
     apiGet<SelectionMeta[]>("/selections?limit=8")
       .then((rows) => alive && setHistory(rows))
@@ -241,7 +243,7 @@ export default function SelectionPage() {
                     }}
                   >
                     {factors.map((f) => (
-                      <option key={f.name} value={f.name}>{f.name}</option>
+                      <option key={f.name} value={f.name}>{factorOptionLabel(f)}</option>
                     ))}
                   </select>
                   <input

frontend/web/app/settings/page.tsx

@@ -0,0 +1,175 @@
+"use client";
+
+/**
+ * 公共配置（/settings）—— 全局唯一一份费率 / 滑点 / 最低佣金 / 复权口径 / 基准。
+ *
+ * 为什么单独一页：这些是「常规配置」，所有回测组合共用，不该在每个策略里重复填
+ * （用户目标第 1 条）。改这里会影响**之后**的回测；已跑过的归档不受影响
+ * （归档的 config_snapshot 固化了当时的成本/复权，可复现）。
+ */
+import { useEffect, useState } from "react";
+import { apiGet, apiPut } from "@/lib/api";
+import type { GlobalConfig } from "@/lib/types";
+import { Banner, Btn, Card, Field, Loading, PageHeader, Pill } from "@/components/ui";
+
+const DEFAULTS: GlobalConfig = {
+  commission_rate: 0.0003,
+  stamp_tax_rate: 0.0005,
+  slippage_rate: 0.001,
+  min_commission: 5,
+  price_adjustment: "hfq",
+  benchmark: "000300.SH",
+};
+
+export default function SettingsPage() {
+  const [cfg, setCfg] = useState<GlobalConfig | null>(null);
+  const [draft, setDraft] = useState<GlobalConfig>(DEFAULTS);
+  const [busy, setBusy] = useState(false);
+  const [err, setErr] = useState("");
+  const [msg, setMsg] = useState("");
+
+  useEffect(() => {
+    let alive = true;
+    apiGet<GlobalConfig>("/config")
+      .then((c) => {
+        if (!alive) return;
+        setCfg(c);
+        setDraft(c);
+      })
+      .catch((e: Error) => alive && setErr(e.message));
+    return () => {
+      alive = false;
+    };
+  }, []);
+
+  async function save() {
+    setBusy(true);
+    setErr("");
+    setMsg("");
+    try {
+      const saved = await apiPut<GlobalConfig>("/config", draft);
+      setCfg(saved);
+      setMsg("公共配置已保存（之后的回测组合将采用新值；已归档的结果不受影响）");
+    } catch (e) {
+      setErr((e as Error).message);
+    } finally {
+      setBusy(false);
+    }
+  }
+
+  // 只比较用户可编辑的字段：忽略 id / updated_at（后端回填，draft 里没有），
+  // 否则刚载入就会因 updated_at:null vs undefined 被判为「有改动」而误亮保存按钮。
+  const editable = (c: GlobalConfig) =>
+    JSON.stringify([c.commission_rate, c.stamp_tax_rate, c.slippage_rate, c.min_commission, c.price_adjustment, c.benchmark]);
+  const dirty = cfg ? editable(cfg) !== editable(draft) : false;
+
+  return (
+    <>
+      <PageHeader
+        title="公共配置"
+        sub="全局唯一的交易成本与行情口径 —— 所有回测组合共用。改动只影响之后的回测，已归档结果按各自快照复现。"
+      />
+
+      {err ? <Banner tone="error">{err}</Banner> : null}
+      {msg ? <Banner tone="info">{msg}</Banner> : null}
+
+      {!cfg ? (
+        <Card><Loading label="读取公共配置…" /></Card>
+      ) : (
+        <Card
+          icon="database"
+          title="交易成本与行情口径"
+          tools={
+            <div className="row" style={{ gap: 8 }}>
+              {dirty ? <Pill tone="warn">有未保存的修改</Pill> : null}
+              <Btn
+                variant="primary"
+                icon="check"
+                loading={busy}
+                disabled={busy || !dirty}
+                onClick={save}
+              >
+                保存配置
+              </Btn>
+            </div>
+          }
+        >
+          <div className="form-grid">
+            <Field label="佣金率" hint="如 0.0003 = 万三；买卖双向收取">
+              <input
+                className="input mono"
+                type="number"
+                inputMode="decimal"
+                step="0.00001"
+                min={0}
+                max={0.01}
+                value={draft.commission_rate}
+                onChange={(e) => setDraft({ ...draft, commission_rate: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="印花税率" hint="仅卖出收取；A 股 0.0005（2023-08 起减半）">
+              <input
+                className="input mono"
+                type="number"
+                inputMode="decimal"
+                step="0.00001"
+                min={0}
+                max={0.01}
+                value={draft.stamp_tax_rate}
+                onChange={(e) => setDraft({ ...draft, stamp_tax_rate: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="滑点率" hint="按成交价比例估计冲击成本；0.0005~0.001 较常见">
+              <input
+                className="input mono"
+                type="number"
+                inputMode="decimal"
+                step="0.0001"
+                min={0}
+                max={0.05}
+                value={draft.slippage_rate}
+                onChange={(e) => setDraft({ ...draft, slippage_rate: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="最低佣金（元/笔）" hint="单笔佣金下限，小额单影响显著；常见 5 元">
+              <input
+                className="input mono"
+                type="number"
+                inputMode="decimal"
+                step={1}
+                min={0}
+                value={draft.min_commission}
+                onChange={(e) => setDraft({ ...draft, min_commission: Number(e.target.value) })}
+              />
+            </Field>
+            <Field label="复权口径" hint="高股息类建议后复权 hfq（把分红再投资计入收益）">
+              <select
+                className="input"
+                value={draft.price_adjustment}
+                onChange={(e) =>
+                  setDraft({ ...draft, price_adjustment: e.target.value as GlobalConfig["price_adjustment"] })
+                }
+              >
+                <option value="hfq">后复权 hfq</option>
+                <option value="qfq">前复权 qfq</option>
+                <option value="none">不复权 none</option>
+              </select>
+            </Field>
+            <Field label="对照基准" hint="仅用于展示对比，不参与交易">
+              <input
+                className="input mono"
+                value={draft.benchmark}
+                onChange={(e) => setDraft({ ...draft, benchmark: e.target.value })}
+              />
+            </Field>
+          </div>
+
+          <div className="hint" style={{ marginTop: 12 }}>
+            费率以**小数**填写（0.0003 = 万三，不是 0.03%）。这里的值是全局默认；每个回测组合运行时
+            会把当时的成本/复权**快照**进归档，所以事后改这里不会改变历史结果的数字。
+          </div>
+        </Card>
+      )}
+    </>
+  );
+}

frontend/web/app/signals/page.tsx

@@ -6,6 +6,7 @@
 import { useEffect, useState } from "react";
 import { apiGet, apiPost } from "@/lib/api";
 import { SymbolLink } from "@/lib/symbols";
+import { factorOptionLabel, pickableFactors } from "@/lib/factors";
 import type {
   FactorMeta,
   SelectionQuery,
@@ -55,7 +56,8 @@ export default function SignalsPage() {
   useEffect(() => {
     let alive = true;
     apiGet<FactorMeta[]>("/factors")
-      .then((list) => alive && list.length > 0 && setFactors(list))
+      // 停用/算不出来的因子不摆进候选（停用仍可被既有策略解析，只是不该再被选中）
+      .then((list) => alive && list.length > 0 && setFactors(pickableFactors(list)))
       .catch((e: Error) => alive && setError(e.message));
     apiGet<SignalMeta[]>("/signals?limit=8").then(setHistory).catch(() => alive && setHistory([]));
     return () => {
@@ -116,7 +118,7 @@ export default function SignalsPage() {
           <Field label="评分因子">
             <select className="input" value={factor} onChange={(e) => setFactor(e.target.value)}>
               {factors.map((f) => (
-                <option key={f.name} value={f.name}>{f.name}</option>
+                <option key={f.name} value={f.name}>{factorOptionLabel(f)}</option>
               ))}
             </select>
           </Field>

frontend/web/app/strategies/page.tsx

@@ -1,23 +1,17 @@
 "use client";
 
 /**
- * 策略库（/strategies）—— 策略的命名资产中心。
+ * 选股策略库（/strategies）—— 只管理「选股条件组合」。
  *
- * 职责：
- * - 列表 + 检索：每个策略显示**一句话说明**与**计算公式**（后端 describe_strategy 推导）。
- * - 新建 / 编辑：复用 StrategyParamsForm（与回测页同一份参数模型与校验）。
- * - 一键回测：`POST /strategies/{id}/expand`（补 period + 资金）→ `POST /jobs` → 轮询 →
- *   就地展示核心指标，并提供「查看实验详情 / 回到回测页看曲线」。
- * - 去回测页：`/backtest?strategy={id}`（回测页载入后可保存为策略、可微调）。
- *
- * 设计取舍：编辑不弹窗而是就地展开表单（页面滚动位置不丢，参数多，弹窗太挤）。
+ * 2026-09 重构后这里**不再有回测参数**（资金/持仓/调仓/费率/区间都移到回测组合与公共配置）。
+ * 每个策略只回答「怎么选」：股票池 + 因子 + 过滤条件。要验证它，去 /backtest 把它
+ * （可与其他策略一起）放进一个回测组合再跑。
  */
 import Link from "next/link";
 import { useCallback, useEffect, useMemo, useState } from "react";
 import { apiDelete, apiGet, apiPost, apiPut } from "@/lib/api";
-import { STAGE_LABEL, submitJob, waitJob, type JobOutcome } from "@/lib/jobs";
-import { recentRange } from "@/lib/dates";
-import type { BacktestResult, FactorMeta, StrategyDefinition } from "@/lib/types";
+import type { ConditionField, FactorMeta, ResearchCondition, SelectionStrategy } from "@/lib/types";
+import { displayUnitOf, fromBase, unitScale } from "@/lib/units";
 import {
   Btn,
   Banner,
@@ -26,40 +20,67 @@ import {
   Loading,
   PageHeader,
   Pill,
-  Progress,
-  BacktestMetrics,
-  Field,
 } from "@/components/ui";
 import {
-  StrategyParamsForm,
-  casePreset,
-  emptyParams,
-  paramsFromStrategy,
-  strategyFromParams,
-  validateParams,
-  type StrategyParams,
-} from "@/components/StrategyParamsForm";
+  SelectionStrategyForm,
+  emptySelectionParams,
+  paramsFromSelectionStrategy,
+  selectionStrategyFromParams,
+  validateSelectionParams,
+  type SelectionStrategyParams,
+} from "@/components/SelectionStrategyForm";
 import { StrategyDocBody, StrategyDocCard } from "@/components/StrategyDocCard";
-import { useStrategyDoc, useStrategyDocById } from "@/lib/strategy";
+import { useStrategyDocById } from "@/lib/strategy";
 
 export default function StrategiesPage() {
-  const [list, setList] = useState<StrategyDefinition[] | null>(null);
+  const [list, setList] = useState<SelectionStrategy[] | null>(null);
   const [factors, setFactors] = useState<FactorMeta[]>([]);
+  const [conditionFields, setConditionFields] = useState<ConditionField[]>([]);
+  /**
+   * 条件下拉用的字段表 = 字段库 + 因子目录里「字段库还没收录」的因子。
+   *
+   * 为什么：参数化因子（`momentum(window=90,direction=…)`）是引擎真认的过滤字段
+   * （`momentum_60 > 0` 一直合法），但它们不在字段库的注册表投影里。这里按名字去重地
+   * 并进来 —— 内置因子本来就在字段库的「因子」分组里，不会重复出现。
+   * 依赖列之类仍由字段库提供；因子条目的单位恒为空（因子是没有单位的无量纲量）。
+   */
+  const filterFields = useMemo<ConditionField[]>(() => {
+    const known = new Set(conditionFields.map((f) => f.name));
+    const factorFields: ConditionField[] = factors
+      .filter((f) => !known.has(f.name) && f.enabled !== false && f.resolvable !== false)
+      .map((f) => ({
+        name: f.name,
+        label: f.label || f.name,
+        description: `${f.description}${f.brief ? ` 用法：${f.brief}` : ""}`,
+        kind: "num",
+        group_name: "因子",
+        unit: "",
+        source: f.source === "custom" ? "custom" : "builtin",
+        enabled: true,
+        sort_order: 900,
+        ops: ["gt", "gte", "lt", "lte", "eq", "ne"],
+      }));
+    return [...conditionFields, ...factorFields];
+  }, [conditionFields, factors]);
+  /** 字段名 → 字段库条目：卡片回显条件时据此取中文名与界面单位。 */
+  const fieldByName = useMemo(
+    () => new Map(filterFields.map((f) => [f.name, f])),
+    [filterFields],
+  );
+  /** 因子名 → 目录条目：卡片/Pill 显示中文名（含参数），而不是又长又生的引擎键。 */
+  const factorByKey = useMemo(() => new Map(factors.map((f) => [f.name, f])), [factors]);
   const [query, setQuery] = useState("");
   const [err, setErr] = useState("");
   const [msg, setMsg] = useState("");
-  const [editing, setEditing] = useState<StrategyParams | null>(null);
+  const [editing, setEditing] = useState<SelectionStrategyParams | null>(null);
   const [editingId, setEditingId] = useState<string | null>(null);
-  // 保存被拦下过 → 立即展开全部校验错误（见 StrategyParamsFormProps.revealErrors）
   const [revealErrors, setRevealErrors] = useState(false);
   const [busy, setBusy] = useState(false);
   const [docId, setDocId] = useState<string | null>(null);
 
-  const range = useMemo(() => recentRange(), []);
-
   const load = useCallback(async () => {
     try {
-      const rows = await apiGet<StrategyDefinition[]>("/strategies");
+      const rows = await apiGet<SelectionStrategy[]>("/strategies");
       setList(rows);
       setErr("");
     } catch (e) {
@@ -74,6 +95,10 @@ export default function StrategiesPage() {
     apiGet<FactorMeta[]>("/factors")
       .then((f) => alive && setFactors(f))
       .catch(() => alive && setFactors([]));
+    // 字段库只取启用项：停用的字段不该出现在条件下拉里（管理在 /fields）
+    apiGet<ConditionField[]>("/condition-fields?include_disabled=false")
+      .then((f) => alive && setConditionFields(f))
+      .catch(() => alive && setConditionFields([]));
     return () => {
       alive = false;
     };
@@ -96,19 +121,18 @@ export default function StrategiesPage() {
     });
   }, [list, query]);
 
-  /* ---------- 新建 / 编辑 ---------- */
   function startCreate() {
     setEditingId(null);
-    setEditing(emptyParams(range));
+    setEditing(emptySelectionParams());
     setDocId(null);
     setMsg("");
     setErr("");
     setRevealErrors(false);
   }
 
-  function startEdit(s: StrategyDefinition) {
+  function startEdit(s: SelectionStrategy) {
     setEditingId(s.id ?? null);
-    setEditing(paramsFromStrategy(s, { ...emptyParams(range) }));
+    setEditing(paramsFromSelectionStrategy(s));
     setDocId(s.id ?? null);
     setMsg("");
     setErr("");
@@ -117,22 +141,22 @@ export default function StrategiesPage() {
 
   async function save() {
     if (!editing) return;
-    const errors = validateParams(editing, { requireMeta: true });
+    const errors = validateSelectionParams(editing);
     if (Object.keys(errors).length) {
       setErr(Object.values(errors)[0]);
-      setRevealErrors(true); // 一次把问题全列出来，而不是让用户逐个试
+      setRevealErrors(true);
       return;
     }
     setBusy(true);
     setErr("");
     try {
-      const body = strategyFromParams(editing, editingId ?? undefined);
+      const body = selectionStrategyFromParams(editing, editingId ?? undefined);
       if (editingId) {
-        await apiPut<StrategyDefinition>(`/strategies/${encodeURIComponent(editingId)}`, body);
-        setMsg(`已更新策略「${body.name}」`);
+        await apiPut<SelectionStrategy>(`/strategies/${encodeURIComponent(editingId)}`, body);
+        setMsg(`已更新选股策略「${body.name}」`);
       } else {
-        const saved = await apiPost<StrategyDefinition>("/strategies", body);
-        setMsg(`已保存策略「${saved.name}」（${saved.id}）`);
+        const saved = await apiPost<SelectionStrategy>("/strategies", body);
+        setMsg(`已保存选股策略「${saved.name}」（${saved.id}）`);
       }
       setEditing(null);
       setEditingId(null);
@@ -145,13 +169,13 @@ export default function StrategiesPage() {
     }
   }
 
-  async function remove(s: StrategyDefinition) {
+  async function remove(s: SelectionStrategy) {
     if (!s.id) return;
-    if (!window.confirm(`删除策略「${s.name}」？此操作不可撤销（已跑过的实验不受影响）。`)) return;
+    if (!window.confirm(`删除选股策略「${s.name}」？引用它的回测组合将无法运行。`)) return;
     setBusy(true);
     try {
       await apiDelete(`/strategies/${encodeURIComponent(s.id)}`);
-      setMsg(`已删除策略「${s.name}」`);
+      setMsg(`已删除选股策略「${s.name}」`);
       await load();
     } catch (e) {
       setErr((e as Error).message);
@@ -163,15 +187,15 @@ export default function StrategiesPage() {
   return (
     <>
       <PageHeader
-        title="策略库"
-        sub="把调好的参数存成命名策略：每个策略都有「一句话说明 + 计算公式 + 执行步骤」，可一键回测、可复现、可对比。"
+        title="选股策略库"
+        sub="每个策略只定义「怎么选」（股票池 + 因子 + 过滤条件）。要验证收益，去「回测组合」把它和一个或多个策略组合起来、填上回测参数再跑。"
         actions={
           <div className="row" style={{ gap: 8 }}>
-            <Link href="/experiments" className="btn">
-              <span>查看实验</span>
+            <Link href="/backtest" className="btn">
+              <span>去建回测组合</span>
             </Link>
             <Btn variant="primary" icon="plus" onClick={startCreate} disabled={busy}>
-              新建策略
+              新建选股策略
             </Btn>
           </div>
         }
@@ -180,11 +204,10 @@ export default function StrategiesPage() {
       {err ? <Banner tone="error">{err}</Banner> : null}
       {msg ? <Banner tone="info">{msg}</Banner> : null}
 
-      {/* ---------- 编辑器 ---------- */}
       {editing ? (
         <Card
           icon={editingId ? "edit" : "plus"}
-          title={editingId ? `编辑策略 · ${editingId}` : "新建策略"}
+          title={editingId ? `编辑选股策略 · ${editingId}` : "新建选股策略"}
           tools={
             <div className="row" style={{ gap: 8 }}>
               <Btn onClick={() => { setEditing(null); setEditingId(null); setDocId(null); }} disabled={busy}>
@@ -196,68 +219,48 @@ export default function StrategiesPage() {
             </div>
           }
         >
-          <StrategyParamsForm
+          <SelectionStrategyForm
             value={editing}
             onChange={setEditing}
             factorOptions={factors}
-            showMeta
-            showPeriod={false}
+            conditionFields={filterFields}
             disabled={busy}
-            errors={validateParams(editing, { requireMeta: true })}
+            errors={validateSelectionParams(editing)}
             revealErrors={revealErrors}
           />
-          <div className="hint" style={{ marginTop: 10 }}>
-            策略只保存「怎么选股/怎么调仓/怎么收费」，**不含回测区间与初始资金** ——
-            这两项在运行回测时才指定，因此同一策略可用于不同区间的复现与对比。
-          </div>
-          <div className="row" style={{ marginTop: 12, gap: 8 }}>
-            <Btn
-              icon="target"
-              disabled={busy}
-              onClick={() =>
-                setEditing({
-                  ...casePreset(range),
-                  name: editing.name,
-                  description: editing.description,
-                })
-              }
-            >
-              载入高股息案例默认参数
-            </Btn>
+          <div className="hint" style={{ marginTop: 12 }}>
+            这里<b>不填</b>资金 / 持仓数 / 持仓时间 / 调仓时机 / 费率 / 复权 / 回测区间 ——
+            那些是回测时才定的，在「回测组合」里填；费率与复权在「公共配置」里设。
           </div>
         </Card>
       ) : null}
 
-      {editing ? (
-        <EditingDoc params={editing} savedId={editingId} />
-      ) : null}
-
+      {editing ? <EditingDoc id={editingId} /> : null}
       {docId && !editing ? <SavedDoc id={docId} onClose={() => setDocId(null)} /> : null}
 
-      {/* ---------- 列表 ---------- */}
       <Card
         icon="archive"
-        title={`已保存策略${list ? ` · ${list.length}` : ""}`}
+        title={`选股策略${list ? ` · ${list.length}` : ""}`}
         tools={
           <input
             className="input input--search"
             placeholder="搜索策略名 / 说明 / 因子 / 条件"
             value={query}
             onChange={(e) => setQuery(e.target.value)}
-            aria-label="搜索策略"
+            aria-label="搜索选股策略"
           />
         }
       >
         {filtered === null ? (
-          <Loading label="读取策略库…" />
+          <Loading label="读取选股策略库…" />
         ) : filtered.length === 0 ? (
           <Empty
             icon="archive"
-            title={list && list.length ? "没有匹配的策略" : "策略库还是空的"}
+            title={list && list.length ? "没有匹配的选股策略" : "选股策略库还是空的"}
             hint={
               list && list.length
                 ? "换个关键词试试。"
-                : "点右上角「新建策略」保存第一个策略；也可以先去回测页调好参数，再点「保存为策略」。"
+                : "点右上角「新建选股策略」保存第一个；定义好「怎么选」后，去回测组合里验证收益。"
             }
           />
         ) : (
@@ -266,8 +269,9 @@ export default function StrategiesPage() {
               <StrategyCard
                 key={s.id ?? s.name}
                 s={s}
-                range={range}
                 busy={busy}
+                fieldByName={fieldByName}
+                factorByKey={factorByKey}
                 onEdit={() => startEdit(s)}
                 onDelete={() => remove(s)}
                 onDoc={() => setDocId(s.id ?? null)}
@@ -282,17 +286,22 @@ export default function StrategiesPage() {
 
 /* ------------------------------------------------------------------ */
 
-/** 未保存参数的实时说明预览 */
-function EditingDoc({ params, savedId }: { params: StrategyParams; savedId: string | null }) {
-  const live = useStrategyDoc(params, !savedId);
-  const saved = useStrategyDocById(savedId);
-  const state = savedId ? saved : live;
+function EditingDoc({ id }: { id: string | null }) {
+  // 编辑未保存时无法预览后端说明（需要 id）；保存后才能看
+  const state = useStrategyDocById(id);
+  if (!id) {
+    return (
+      <Card icon="book" title="策略说明与计算公式">
+        <div className="hint">保存后即可在此预览后端按选股条件推导的说明与公式。</div>
+      </Card>
+    );
+  }
   return (
     <StrategyDocCard
       doc={state.doc}
       loading={state.loading}
       error={state.error}
-      title="策略说明与计算公式（随参数实时更新）"
+      title="策略说明与计算公式（后端按选股条件推导）"
     />
   );
 }
@@ -318,120 +327,64 @@ function SavedDoc({ id, onClose }: { id: string; onClose: () => void }) {
   );
 }
 
-/** 单个策略卡片：说明 + 参数摘要 + 一键回测 */
 function StrategyCard({
   s,
-  range,
   busy,
+  fieldByName,
+  factorByKey,
   onEdit,
   onDelete,
   onDoc,
 }: {
-  s: StrategyDefinition;
-  range: { start: string; end: string };
+  s: SelectionStrategy;
   busy: boolean;
+  fieldByName: Map<string, ConditionField>;
+  factorByKey: Map<string, FactorMeta>;
   onEdit: () => void;
   onDelete: () => void;
   onDoc: () => void;
 }) {
-  const [start, setStart] = useState("2020-01-01");
-  const [end, setEnd] = useState(range.end);
-  const [capital, setCapital] = useState(1_000_000);
-  const [running, setRunning] = useState(false);
-  const [jobId, setJobId] = useState("");
-  const [result, setResult] = useState<BacktestResult | null>(null);
-  const [stage, setStage] = useState("");
-  const [expId, setExpId] = useState("");
-  const [error, setError] = useState("");
-  const [open, setOpen] = useState(false);
-
-  const sel = s.selection ?? {};
-  const costs = s.costs ?? {};
-
-  async function run() {
-    if (!s.id) return;
-    if (start >= end) {
-      setError("开始日期必须早于结束日期");
-      return;
-    }
-    setRunning(true);
-    setError("");
-    setResult(null);
-    setExpId("");
-    try {
-      const spec = await apiPost<Record<string, unknown>>(
-        `/strategies/${encodeURIComponent(s.id)}/expand`,
-        { period: [start, end], initial_capital: capital }
-      );
-      const { job_id } = await submitJob(spec as never);
-      setJobId(job_id);
-      setStage("queued");
-      const out: JobOutcome<BacktestResult> = await waitJob<BacktestResult>(job_id, 900_000, (info) =>
-        setStage(info.stage)
-      );
-      if (out.status === "success" && out.result) {
-        setResult(out.result);
-        setExpId(out.experimentId ?? "");
-      } else {
-        setError(`任务${out.status}${out.error ? `：${out.error}` : ""}`);
-      }
-    } catch (e) {
-      setError((e as Error).message);
-    } finally {
-      setRunning(false);
-      setJobId("");
-      setStage("");
-    }
-  }
-
+  const u = s.universe ?? {};
   return (
     <div className="card" style={{ display: "flex", flexDirection: "column", gap: 10 }}>
       <div className="between">
         <div style={{ minWidth: 0 }}>
-          <div className="card__title" style={{ marginBottom: 2 }}>
-            {s.name}
-          </div>
+          <div className="card__title" style={{ marginBottom: 2 }}>{s.name}</div>
           <div className="row" style={{ gap: 6, flexWrap: "wrap" }}>
             <span className="mono hint">{s.id}</span>
             {s.created_at ? <span className="hint">创建 {String(s.created_at).slice(0, 10)}</span> : null}
           </div>
         </div>
         <Pill tone="violet" icon="target">
-          {s.factors?.map((f) => f.name).join(" + ") || "—"}
+          {s.factors?.map((f) => factorLabel(factorByKey.get(f.name), f.name)).join(" + ") || "—"}
         </Pill>
       </div>
 
-      <div className="strategy-desc">{s.description || "（无说明：建议补一句话说明，便于日后识别）"}</div>
+      <div className="strategy-desc">{s.description || "（无说明：建议补一句话，便于日后识别）"}</div>
 
       <div className="chips">
         <span className="chip">
-          候选池 <b>{sel.top_n ?? "—"}</b> → 持仓 <b>{sel.hold_top_x ?? sel.top_n ?? "—"}</b>
-        </span>
-        <span className="chip">
-          择股 <b>{s.selection_interval_months ?? "跟随 y"}</b> 月 / 调仓{" "}
-          <b>{s.rebalance_interval_months ?? "跟随 m"}</b> 月
-        </span>
-        <span className="chip">
-          复权 <b>{adjLabel(s.price_adjustment)}</b>
-        </span>
-        <span className="chip">
-          {s.universe?.exclude_st ? "剔除 ST" : "含 ST"} · 费率{" "}
-          <b>{((costs.commission_rate ?? 0) * 100).toFixed(3)}%</b> + 印花{" "}
-          <b>{((costs.stamp_tax_rate ?? 0) * 100).toFixed(2)}%</b>
+          股票池 <b>{u.index_code ? `${u.index_code} 成分` : "全市场"}</b>
+          {u.exclude_st ? " · 剔 ST" : ""}
+          {u.min_listing_days ? ` · ≥${u.min_listing_days}天` : ""}
         </span>
         {(s.conditions ?? []).length ? (
           <span className="chip">
-            条件 <b>{(s.conditions ?? []).map((c) => `${c.field} ${opLabel(c.op)} ${c.value ?? ""}`).join(" 且 ")}</b>
+            条件{" "}
+            <b>
+              {(s.conditions ?? [])
+                .map((c) => `${fieldByName.get(c.field)?.label ?? c.field} ${opLabel(c.op)} ${condValueText(c, fieldByName.get(c.field))}`)
+                .join(" 且 ")}
+            </b>
           </span>
-        ) : null}
+        ) : (
+          <span className="chip">无过滤条件</span>
+        )}
       </div>
 
       <div className="strategy-actions">
-        <Btn size="sm" variant="primary" icon="play" loading={running} disabled={running || busy} onClick={run}>
-          {running ? "后台运行中…" : "一键回测"}
-        </Btn>
         <Link href={`/backtest?strategy=${encodeURIComponent(s.id ?? "")}`} className="btn btn--sm">
-          <span>载入回测页（可微调）</span>
+          <span>加入回测组合</span>
         </Link>
         <Btn size="sm" icon="book" onClick={onDoc} disabled={busy}>
           看说明/公式
@@ -443,77 +396,19 @@ function StrategyCard({
           删除
         </Btn>
       </div>
-
-      {/* 运行区间（默认 2020-01-01 ~ 最近交易日） */}
-      <details open={open} onToggle={(e) => setOpen((e.target as HTMLDetailsElement).open)}>
-        <summary className="hint" style={{ cursor: "pointer" }}>
-          回测区间与资金（一键回测使用）
-        </summary>
-        <div className="form-grid" style={{ marginTop: 8 }}>
-          <Field label="开始日期">
-            <input type="date" className="input" value={start} onChange={(e) => setStart(e.target.value)} disabled={running} />
-          </Field>
-          <Field label="结束日期">
-            <input type="date" className="input" value={end} onChange={(e) => setEnd(e.target.value)} disabled={running} />
-          </Field>
-          <Field label="初始资金（元）">
-            <input
-              type="number"
-              className="input"
-              step={100000}
-              min={10000}
-              value={capital}
-              onChange={(e) => setCapital(Number(e.target.value))}
-              disabled={running}
-            />
-          </Field>
-        </div>
-      </details>
-
-      {running ? (
-        <Progress
-          value={35}
-          label={
-            <>
-              任务 <span className="mono">{jobId || "排队中…"}</span> 后台执行中（全市场回测通常 1~5 分钟）
-            </>
-          }
-        />
-      ) : null}
-      {error ? <Banner tone="error">{error}</Banner> : null}
-
-      {result ? (
-        <div>
-          <div className="between" style={{ marginBottom: 8 }}>
-            <Pill tone="pos" icon="check">
-              回测完成
-            </Pill>
-            <Link
-              href={expId ? `/experiments?exp=${encodeURIComponent(expId)}` : "/experiments"}
-              className="btn btn--sm"
-            >
-              <span>在实验中对比</span>
-            </Link>
-            {expId ? (
-              <>
-                <Link href={`/experiments/${encodeURIComponent(expId)}`} className="btn btn--sm">
-                  <span>打开归档（完整快照）</span>
-                </Link>
-                <Link href={`/backtest?from_experiment=${encodeURIComponent(expId)}`} className="btn btn--sm">
-                  <span>以此参数再跑</span>
-                </Link>
-              </>
-            ) : null}
-          </div>
-          <BacktestMetrics s={result.summary} />
-        </div>
-      ) : null}
     </div>
   );
 }
 
-function adjLabel(m?: string): string {
-  return m === "hfq" ? "后复权" : m === "qfq" ? "前复权" : "不复权";
+/**
+ * 卡片上的因子名：优先中文名（含参数，如「动量（窗口 90，越高越好）」）。
+ *
+ * 参数化因子的引擎键很长（`momentum(window=90,direction=higher_is_better)`），
+ * 卡片上直接显示会把布局撑坏；找不到目录条目时退回键名 —— 预览不到就照实显示，
+ * 不猜、不截断成看起来像另一个因子。
+ */
+function factorLabel(meta: FactorMeta | undefined, name: string): string {
+  return meta?.label || name;
 }
 
 function opLabel(op: string): string {
@@ -521,3 +416,21 @@ function opLabel(op: string): string {
     { gt: ">", gte: "≥", lt: "<", lte: "≤", eq: "=", ne: "≠", in: "属于", not_in: "不属于" }[op] ?? op
   );
 }
+
+/** 条件取值的人类可读文本：存的是**基准单位**，这里按字段库的界面单位回显。
+ *
+ * 卡片上必须带单位（如「≥ 5 亿元」）：引擎按基准单位比较，用户看到的若是裸数字，
+ * 就会把「5 亿元」读成「5 万元」—— 这正是「单位可选」要避免的误读。
+ */
+function condValueText(c: ResearchCondition, meta?: ConditionField): string {
+  if (c.ref) return `字段 ${c.ref}`;
+  const scale = unitScale(meta);
+  const unit = displayUnitOf(meta) || (meta?.base_unit ?? meta?.unit ?? "");
+  const show = (x: unknown) => {
+    const n = Number(x);
+    return Number.isNaN(n) ? String(x ?? "") : String(fromBase(n, scale));
+  };
+  const body = Array.isArray(c.value) ? c.value.map(show).join("、") : show(c.value);
+  return unit ? `${body} ${unit}` : body;
+}
+