From 8ec110a885bb7bdeba986e09b340fcb0cd9d07a2 Mon Sep 17 00:00:00 2001
From: qian <wuchengqian5@163.com>
Date: Sun, 13 Sep 2026 00:25:20 +0800
Subject: [PATCH] =?UTF-8?q?feat(model):=E4=BC=98=E5=8C=96=E6=A8=A1?=
 =?UTF-8?q?=E5=9E=8B=E4=BB=B7=E6=A0=BC=E8=AE=BE=E7=BD=AE=E6=96=B9=E5=BC=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 api/admin/v1/model.go                         |   10 +
 internal/logic/admin/model.go                 |  276 ++-
 internal/logic/billing/pricing.go             |   24 +-
 internal/logic/billing/pricing_blob_test.go   |   47 +
 internal/logic/billing/task_billing.go        |   15 +-
 internal/logic/billing/task_billing_test.go   |   32 +
 .../src/components/ModelPricingModal.vue      | 1909 +++++++++--------
 .../components/PricingParamRulesEditor.vue    |  563 +++++
 .../components/PricingTimeSegmentsEditor.vue  |  412 ++++
 9 files changed, 2304 insertions(+), 984 deletions(-)
 create mode 100644 web/admin/src/components/PricingParamRulesEditor.vue
 create mode 100644 web/admin/src/components/PricingTimeSegmentsEditor.vue

diff --git a/api/admin/v1/model.go b/api/admin/v1/model.go
index 036fdda..f69a7dd 100644
--- a/api/admin/v1/model.go
+++ b/api/admin/v1/model.go
@@ -147,6 +147,11 @@ type PricingGetRes struct {
 	List             []PricingItem         `json:"list"`
 	TimeSegments     []TimeSegmentItem     `json:"time_segments" dc:"时段定价列表（pricing JSONB 顶层）"`
 	ParamMultipliers []ParamMultiplierItem `json:"param_multipliers" dc:"参数倍率规则（pricing JSONB 顶层，横切所有计费模式）"`
+	// 官方参考定价（official_pricing JSONB 还原，结构与计费定价完全一致；OfficialItems nil=未配置）。
+	// 非计费依据，管理端按官方价 × 折扣快速定价 / 计算现价几折以此为准
+	OfficialItems            []PricingItem         `json:"official_items" dc:"官方参考定价项（tiered 展开为多行；nil=未配置）"`
+	OfficialTimeSegments     []TimeSegmentItem     `json:"official_time_segments" dc:"官方参考-时段定价"`
+	OfficialParamMultipliers []ParamMultiplierItem `json:"official_param_multipliers" dc:"官方参考-参数倍率规则"`
 	// 以下为定价行展示字段
 	PriceNote       string `json:"price_note" dc:"价格说明（仅管理后台可见的内部备注）"`
 	DiscountLabel   string `json:"discount_label" dc:"折扣标签（对外展示，如 7折起）"`
@@ -160,6 +165,11 @@ type PricingSetReq struct {
 	Items            []PricingItem         `json:"items" v:"required" dc:"定价列表"`
 	TimeSegments     []TimeSegmentItem     `json:"time_segments" dc:"时段定价（可选，全量替换；空数组清除时段配置）"`
 	ParamMultipliers []ParamMultiplierItem `json:"param_multipliers" dc:"参数倍率规则（可选，全量替换；空数组清除）"`
+	// 官方参考定价（可选，结构与计费定价完全一致，支持全部四种计费模式 + 时段/倍率）：
+	// OfficialItems nil=本次不动库内官方定价；非 nil=全量替换（三个数组全空=清除）。金额本位币，非计费依据
+	OfficialItems            []PricingItem         `json:"official_items" dc:"官方参考定价项（nil=不修改；非 nil=全量替换，与另两个官方数组全空=清除）"`
+	OfficialTimeSegments     []TimeSegmentItem     `json:"official_time_segments" dc:"官方参考-时段定价（随 official_items 一并全量替换）"`
+	OfficialParamMultipliers []ParamMultiplierItem `json:"official_param_multipliers" dc:"官方参考-参数倍率规则（随 official_items 一并全量替换）"`
 	// 以下为定价行展示字段（全量替换语义：空=清除；price_note 不透出到租户端）
 	PriceNote       string `json:"price_note" dc:"价格说明（仅内部可见）"`
 	DiscountLabel   string `json:"discount_label" dc:"折扣标签（对外展示）"`
diff --git a/internal/logic/admin/model.go b/internal/logic/admin/model.go
index b7336b1..e7e2fec 100644
--- a/internal/logic/admin/model.go
+++ b/internal/logic/admin/model.go
@@ -463,6 +463,7 @@ func (s *sAdmin) GetModelPricing(ctx context.Context, req *v1.PricingGetReq) (*v
 	var row *struct {
 		BillingMode     string  `json:"billing_mode" orm:"billing_mode"`
 		Pricing         string  `json:"pricing" orm:"pricing"`
+		OfficialPricing string  `json:"official_pricing" orm:"official_pricing"`
 		PriceNote       *string `json:"price_note" orm:"price_note"`
 		DiscountLabel   *string `json:"discount_label" orm:"discount_label"`
 		PriceChangeNote *string `json:"price_change_note" orm:"price_change_note"`
@@ -475,68 +476,99 @@ func (s *sAdmin) GetModelPricing(ctx context.Context, req *v1.PricingGetReq) (*v
 		return nil, err
 	}
 
-	result := make([]v1.PricingItem, 0, 1)
-	var timeSegments []billing.TimeSegment
-	var paramRules []billing.ParamRule
+	var result []v1.PricingItem
+	var timeSegments []v1.TimeSegmentItem
+	var paramRules []v1.ParamMultiplierItem
+	var officialItems []v1.PricingItem
+	var officialTimeSegments []v1.TimeSegmentItem
+	var officialParamRules []v1.ParamMultiplierItem
 	var priceNote, discountLabel, priceChangeNote string
 	if row != nil {
-		mode := row.BillingMode
-		blob := billing.ParsePricingBlob(row.Pricing)
-		if blob != nil {
-			paramRules = blob.ParamMultipliers
-		}
-		switch {
-		case blob != nil && len(blob.Tiers) > 0:
-			// tiered：tiers 数组还原为多行 PricingItem（与旧档位行结构一致）
-			for _, tier := range blob.Tiers {
-				result = append(result, v1.PricingItem{
-					BillingMode: mode,
-					MinTokens:   tier.MinTokens,
-					MaxTokens:   tier.MaxTokens,
-					InputPrice:  tier.InputPrice,
-					OutputPrice: tier.OutputPrice,
-				})
-			}
-		default:
-			item := v1.PricingItem{BillingMode: mode}
-			if blob != nil {
-				if blob.InputPrice != nil {
-					item.InputPrice = *blob.InputPrice
-				}
-				if blob.OutputPrice != nil {
-					item.OutputPrice = *blob.OutputPrice
-				}
-				if blob.CacheReadPrice != nil {
-					item.CacheReadPrice = *blob.CacheReadPrice
-				}
-				if blob.CacheCreationPrice != nil {
-					item.CacheCreationPrice = *blob.CacheCreationPrice
-				}
-				if blob.Price != nil {
-					p := *blob.Price
-					item.PerRequestPrice = &p
-				}
-				if len(blob.Prices) > 0 {
-					item.PerSecondPrices = blob.Prices
-				}
-				timeSegments = blob.TimeSegments
-			}
-			result = append(result, item)
+		// 主定价：pricing JSONB → items + 时段 + 倍率（与官方参考定价共用展开逻辑）
+		result, timeSegments, paramRules = expandPricingBlob(row.BillingMode, billing.ParsePricingBlob(row.Pricing))
+
+		// 官方参考定价：official_pricing JSONB 同构展开；未配置（NULL/解析失败）时三个字段保持 nil
+		offMode, offBlob := officialBlobFromJSON(row.OfficialPricing)
+		if offBlob != nil {
+			officialItems, officialTimeSegments, officialParamRules = expandPricingBlob(offMode, offBlob)
 		}
+
 		priceNote = derefStr(row.PriceNote)
 		discountLabel = derefStr(row.DiscountLabel)
 		priceChangeNote = derefStr(row.PriceChangeNote)
 	}
 	return &v1.PricingGetRes{
-		List:             result,
-		TimeSegments:     timeSegmentsToAPI(timeSegments),
-		ParamMultipliers: paramMultipliersToAPI(paramRules),
-		PriceNote:        priceNote,
-		DiscountLabel:    discountLabel,
-		PriceChangeNote:  priceChangeNote,
+		List:                     result,
+		TimeSegments:             timeSegments,
+		ParamMultipliers:         paramRules,
+		OfficialItems:            officialItems,
+		OfficialTimeSegments:     officialTimeSegments,
+		OfficialParamMultipliers: officialParamRules,
+		PriceNote:                priceNote,
+		DiscountLabel:            discountLabel,
+		PriceChangeNote:          priceChangeNote,
 	}, nil
 }
 
+// expandPricingBlob pricing JSONB 内存形态 → API 响应结构（items 行 + 时段 + 参数倍率）。
+// tiered 的 tiers 数组还原为多行 PricingItem（与旧档位行结构一致）。blob 为 nil 时
+// 仍返回单行空 item（mode 随入参），保持「无定价」的既有响应形态。主定价与官方参考定价共用。
+func expandPricingBlob(mode string, blob *billing.PricingBlob) ([]v1.PricingItem, []v1.TimeSegmentItem, []v1.ParamMultiplierItem) {
+	if blob == nil {
+		blob = &billing.PricingBlob{}
+	}
+	items := make([]v1.PricingItem, 0, 1)
+	switch {
+	case len(blob.Tiers) > 0:
+		// tiered：tiers 数组还原为多行 PricingItem（与旧档位行结构一致）。
+		// 逐档缓存价随行还原；首档无档内值时回退 blob 顶层锚点缓存价（存量数据兼容）
+		for i, tier := range blob.Tiers {
+			item := v1.PricingItem{
+				BillingMode: mode,
+				MinTokens:   tier.MinTokens,
+				MaxTokens:   tier.MaxTokens,
+				InputPrice:  tier.InputPrice,
+				OutputPrice: tier.OutputPrice,
+			}
+			if tier.CacheReadPrice != nil {
+				item.CacheReadPrice = *tier.CacheReadPrice
+			} else if i == 0 && blob.CacheReadPrice != nil {
+				item.CacheReadPrice = *blob.CacheReadPrice
+			}
+			if tier.CacheCreationPrice != nil {
+				item.CacheCreationPrice = *tier.CacheCreationPrice
+			} else if i == 0 && blob.CacheCreationPrice != nil {
+				item.CacheCreationPrice = *blob.CacheCreationPrice
+			}
+			items = append(items, item)
+		}
+	default:
+		item := v1.PricingItem{BillingMode: mode}
+		if blob.InputPrice != nil {
+			item.InputPrice = *blob.InputPrice
+		}
+		if blob.OutputPrice != nil {
+			item.OutputPrice = *blob.OutputPrice
+		}
+		if blob.CacheReadPrice != nil {
+			item.CacheReadPrice = *blob.CacheReadPrice
+		}
+		if blob.CacheCreationPrice != nil {
+			item.CacheCreationPrice = *blob.CacheCreationPrice
+		}
+		if blob.Price != nil {
+			p := *blob.Price
+			item.PerRequestPrice = &p
+		}
+		if len(blob.Prices) > 0 {
+			item.PerSecondPrices = blob.Prices
+		}
+		items = append(items, item)
+	}
+	// 时段与倍率横切所有计费模式（含 tiered），随 blob 顶层还原
+	return items, timeSegmentsToAPI(blob.TimeSegments), paramMultipliersToAPI(blob.ParamMultipliers)
+}
+
 // derefStr 字符串指针安全解引用（NULL → 空串）
 func derefStr(s *string) string {
 	if s == nil {
@@ -671,20 +703,125 @@ func writePricingForModel(ctx context.Context, modelDBID int64, items []v1.Prici
 		return err
 	}
 
-	// 全量替换语义：删旧行插新行（保留展示字段列随 insert 重置为默认，随后由调用方回写）
-	if _, err := dao.MdlPricing.Ctx(ctx).Where("model_id", modelDBID).Delete(); err != nil {
-		return err
-	}
-	if _, err := dao.MdlPricing.Ctx(ctx).Insert(do.MdlPricing{
-		ModelId:     modelDBID,
-		BillingMode: items[0].BillingMode,
-		Pricing:     string(blobJSON),
-	}); err != nil {
+	// 全量替换语义改为 upsert：ON CONFLICT (model_id) 命中时只覆盖 billing_mode / pricing，
+	// official_pricing 与展示字段列未涉及时保留原值——模型导入共用本函数，不得误清人工
+	// 核对落库的官方定价；展示字段随后仍由调用方按「空=清除」全量回写，行为与删行重插等价。
+	// 列名直写而非 do 字段，与 gf gen dao 生成物解耦（同 writePricingDisplayFieldsForModel）。
+	if _, err := dao.MdlPricing.Ctx(ctx).
+		Data(g.Map{
+			"model_id":     modelDBID,
+			"billing_mode": items[0].BillingMode,
+			"pricing":      string(blobJSON),
+		}).
+		OnConflict("model_id").
+		OnDuplicate(g.Map{
+			"billing_mode": gdb.Raw("excluded.billing_mode"),
+			"pricing":      gdb.Raw("excluded.pricing"),
+		}).
+		Save(); err != nil {
 		return err
 	}
 	return nil
 }
 
+// officialPricingBlob official_pricing JSONB 的内存形态：billing_mode 键 + PricingBlob 字段平铺
+// （encoding/json 对嵌入结构体平铺序列化），与计费定价 pricing JSONB 完全同构，
+// 仅多 billing_mode 键——官方定价无独立模式列，模式随 JSONB 存储。
+type officialPricingBlob struct {
+	BillingMode string `json:"billing_mode"`
+	billing.PricingBlob
+}
+
+// buildOfficialBlob 官方定价项 + 时段/倍率 → PricingBlob（与计费定价同构，复用同一构建管线）。
+// 全空（价格维度 + tiers + 时段 + 倍率均无）返回 nil，调用方按清除处理（写 NULL）。
+// 官方价是折扣换算的参照基准而非计费依据，是可选配置：per_second 空/全零矩阵属「未配置」
+// 形态，不走计费定价的矩阵强校验（否则未配置形态会报错，连带阻断主定价保存），
+// 直接落成空 blob 交给下方全空判断；其余模式沿用 BuildPricingBlob 结构校验与时段/倍率 FromAPI 校验。
+func buildOfficialBlob(items []v1.PricingItem, segments []v1.TimeSegmentItem, rules []v1.ParamMultiplierItem) (*billing.PricingBlob, error) {
+	segs, err := timeSegmentsFromAPI(segments)
+	if err != nil {
+		return nil, err
+	}
+	paramRules, err := paramMultipliersFromAPI(rules)
+	if err != nil {
+		return nil, err
+	}
+	input := pricingItemsToInput(items)
+	var blob *billing.PricingBlob
+	if len(input) > 0 && input[0].BillingMode == "per_second" && !perSecondMatrixHasPositivePrice(input[0].PerSecondPrices) {
+		blob = &billing.PricingBlob{}
+	} else {
+		blob, err = billing.BuildPricingBlob(input)
+		if err != nil {
+			return nil, err
+		}
+	}
+	blob.TimeSegments = segs
+	blob.ParamMultipliers = paramRules
+	empty := blob.InputPrice == nil && blob.OutputPrice == nil && blob.CacheReadPrice == nil &&
+		blob.CacheCreationPrice == nil && len(blob.Tiers) == 0 && blob.Price == nil &&
+		len(blob.Prices) == 0 && len(blob.TimeSegments) == 0 && len(blob.ParamMultipliers) == 0
+	if empty {
+		return nil, nil
+	}
+	return blob, nil
+}
+
+// perSecondMatrixHasPositivePrice 按秒矩阵是否存在任一正价（空矩阵/全零价=未配置形态）
+func perSecondMatrixHasPositivePrice(prices map[string]float64) bool {
+	for _, p := range prices {
+		if p > 0 {
+			return true
+		}
+	}
+	return false
+}
+
+// officialBlobFromJSON 解析 official_pricing JSONB → (billing_mode, PricingBlob)。
+// 空串/null/解析失败返回 ("", nil)，调用方按未配置处理（参照字段，解析失败不阻断定价编辑）。
+func officialBlobFromJSON(raw string) (string, *billing.PricingBlob) {
+	if raw == "" || raw == "null" {
+		return "", nil
+	}
+	wrapped := officialPricingBlob{}
+	if err := json.Unmarshal([]byte(raw), &wrapped); err != nil {
+		return "", nil
+	}
+	mode := wrapped.BillingMode
+	if mode == "" {
+		mode = "token"
+	}
+	return mode, &wrapped.PricingBlob
+}
+
+// writeOfficialPricingForModel 官方参考定价写入模型定价行（official_pricing 列整体替换，
+// 全空=清除写 NULL）。与 pricing 列同构：BuildPricingBlob 构建 + 时段/倍率并入 blob 顶层，
+// 支持全部四种计费模式。列名直写而非 do 字段，与 gf gen dao 生成物解耦
+// （同 writePricingDisplayFieldsForModel）。需在定价行存在之后执行。调用方需保证事务 ctx 传播。
+func writeOfficialPricingForModel(ctx context.Context, modelDBID int64, items []v1.PricingItem, segments []v1.TimeSegmentItem, rules []v1.ParamMultiplierItem) error {
+	blob, err := buildOfficialBlob(items, segments, rules)
+	if err != nil {
+		return err
+	}
+	data := any(gdb.Raw("NULL"))
+	if blob != nil {
+		mode := "token"
+		if len(items) > 0 {
+			mode = items[0].BillingMode
+		}
+		raw, mErr := json.Marshal(officialPricingBlob{BillingMode: mode, PricingBlob: *blob})
+		if mErr != nil {
+			return mErr
+		}
+		data = string(raw)
+	}
+	_, err = dao.MdlPricing.Ctx(ctx).
+		Where("model_id", modelDBID).
+		Data(g.Map{"official_pricing": data}).
+		Update()
+	return err
+}
+
 // writeTimeSegmentsForModel 把时段定价并入模型定价行的 pricing JSONB 顶层（time_segments 键），
 // 空列表=清除（全量替换语义，写 "[]" 而非删除键：nil 切片会序列化成 "null"，语义不明确）。
 // 定价保存与模型导入共用。jsonb_set 只更新目标键，不覆盖 JSON 内其他计费字段。
@@ -748,6 +885,16 @@ func (s *sAdmin) SetModelPricing(ctx context.Context, req *v1.PricingSetReq) (*v
 		return nil, err
 	}
 
+	// 官方参考定价的时段/倍率预校验（与主定价同一套校验；OfficialItems nil=本次不动官方定价）
+	if req.OfficialItems != nil {
+		if _, err := timeSegmentsFromAPI(req.OfficialTimeSegments); err != nil {
+			return nil, gerror.Wrap(err, "官方参考定价")
+		}
+		if _, err := paramMultipliersFromAPI(req.OfficialParamMultipliers); err != nil {
+			return nil, gerror.Wrap(err, "官方参考定价")
+		}
+	}
+
 	// 先查模型编码，供事务提交后按模型清除所有租户的价格缓存
 	var model struct {
 		ModelId string `json:"model_id"`
@@ -765,6 +912,15 @@ func (s *sAdmin) SetModelPricing(ctx context.Context, req *v1.PricingSetReq) (*v
 			return err
 		}
 
+		// 官方参考定价（OfficialItems nil=本次不动库内值；三个官方数组全空=清除）。
+		// 与 pricing 列同构，支持全部四种计费模式 + 时段/倍率。官方价非计费依据，
+		// 不触发价格缓存失效
+		if req.OfficialItems != nil {
+			if err := writeOfficialPricingForModel(ctx, req.ModelID, req.OfficialItems, req.OfficialTimeSegments, req.OfficialParamMultipliers); err != nil {
+				return gerror.Wrap(err, "官方参考定价")
+			}
+		}
+
 		// 时段定价并入 JSON 顶层（空=清除，全量替换语义；需在定价行插入之后执行）
 		if err := writeTimeSegmentsForModel(ctx, req.ModelID, req.TimeSegments); err != nil {
 			return err
diff --git a/internal/logic/billing/pricing.go b/internal/logic/billing/pricing.go
index 8ca65e4..dd47179 100644
--- a/internal/logic/billing/pricing.go
+++ b/internal/logic/billing/pricing.go
@@ -702,10 +702,12 @@ func BuildPricingBlob(items []PricingItemInput) (*PricingBlob, error) {
 		}
 		for _, item := range items {
 			blob.Tiers = append(blob.Tiers, pricingTierRow{
-				MinTokens:   item.MinTokens,
-				MaxTokens:   item.MaxTokens,
-				InputPrice:  item.InputPrice,
-				OutputPrice: item.OutputPrice,
+				MinTokens:          item.MinTokens,
+				MaxTokens:          item.MaxTokens,
+				InputPrice:         item.InputPrice,
+				OutputPrice:        item.OutputPrice,
+				CacheReadPrice:     positivePtr(item.CacheReadPrice),
+				CacheCreationPrice: positivePtr(item.CacheCreationPrice),
 			})
 		}
 		return blob, nil
@@ -776,12 +778,16 @@ func tiersHavePrice(tiers []pricingTierRow) bool {
 	return false
 }
 
-// pricingTierRow 定价阶梯行（绝对价格）
+// pricingTierRow 定价阶梯行（绝对价格）。
+// 逐档缓存价为可选键（omitempty，旧数据缺键 unmarshal 为 nil，无需迁移）：
+// 编辑器逐档缓存价落库于此；计费引擎的缓存 token 计费仍取 blob 顶层锚点缓存价，不读档内字段
 type pricingTierRow struct {
-	MinTokens   int64   `json:"min_tokens"`
-	MaxTokens   *int64  `json:"max_tokens"`
-	InputPrice  float64 `json:"input_price"`
-	OutputPrice float64 `json:"output_price"`
+	MinTokens          int64    `json:"min_tokens"`
+	MaxTokens          *int64   `json:"max_tokens"`
+	InputPrice         float64  `json:"input_price"`
+	OutputPrice        float64  `json:"output_price"`
+	CacheReadPrice     *float64 `json:"cache_read_price,omitempty"`
+	CacheCreationPrice *float64 `json:"cache_creation_price,omitempty"`
 }
 
 // effectiveTimeMultiplier 时段乘数归一化：0/负值视为 1.0。
diff --git a/internal/logic/billing/pricing_blob_test.go b/internal/logic/billing/pricing_blob_test.go
index 35fda75..51dad0e 100644
--- a/internal/logic/billing/pricing_blob_test.go
+++ b/internal/logic/billing/pricing_blob_test.go
@@ -101,3 +101,50 @@ func TestBuildPricingBlob_ZeroPricesOmitted(t *testing.T) {
 		t.Fatalf("expected empty blob json, got %s", raw)
 	}
 }
+
+// TestBuildPricingBlob_TieredPerTierCachePrices 阶梯逐档缓存价：档内键随行落库，
+// 顶层锚点缓存价照旧写入（计费引擎的缓存 token 计费读顶层，不读档内字段）。
+// JSONB 往返后两处都完整保留；旧格式（档内无缓存键）unmarshal 为 nil 不报错。
+func TestBuildPricingBlob_TieredPerTierCachePrices(t *testing.T) {
+	max := int64(100000)
+	blob, err := BuildPricingBlob([]PricingItemInput{
+		{BillingMode: "tiered", MinTokens: 0, MaxTokens: &max, InputPrice: 15, OutputPrice: 75, CacheReadPrice: 1.5, CacheCreationPrice: 18.75},
+		{BillingMode: "tiered", MinTokens: 100000, InputPrice: 12, OutputPrice: 60, CacheReadPrice: 1.2, CacheCreationPrice: 15},
+	})
+	if err != nil {
+		t.Fatalf("build: %v", err)
+	}
+	// 顶层锚点缓存价保留（计费引擎读取口径）
+	if blob.CacheReadPrice == nil || *blob.CacheReadPrice != 1.5 || blob.CacheCreationPrice == nil || *blob.CacheCreationPrice != 18.75 {
+		t.Fatalf("anchor cache prices lost: %+v", blob)
+	}
+	// 逐档缓存价落行
+	if blob.Tiers[0].CacheReadPrice == nil || *blob.Tiers[0].CacheReadPrice != 1.5 {
+		t.Fatalf("tier0 cache_read_price lost: %+v", blob.Tiers[0])
+	}
+	if blob.Tiers[1].CacheReadPrice == nil || *blob.Tiers[1].CacheReadPrice != 1.2 {
+		t.Fatalf("tier1 cache_read_price lost: %+v", blob.Tiers[1])
+	}
+
+	// JSONB 往返（mdl_pricing.pricing 的真实存取路径）
+	raw, err := json.Marshal(blob)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+	parsed := ParsePricingBlob(string(raw))
+	if parsed == nil {
+		t.Fatal("parse failed")
+	}
+	if parsed.CacheReadPrice == nil || *parsed.CacheReadPrice != 1.5 {
+		t.Fatalf("roundtrip anchor cache lost: %+v", parsed)
+	}
+	if parsed.Tiers[1].CacheCreationPrice == nil || *parsed.Tiers[1].CacheCreationPrice != 15 {
+		t.Fatalf("roundtrip tier1 cache_creation lost: %+v", parsed.Tiers[1])
+	}
+
+	// 旧格式（档内无缓存键、顶层有锚点）：unmarshal 不报错，档内为 nil
+	legacy := ParsePricingBlob(`{"tiers":[{"min_tokens":0,"input_price":15,"output_price":75}],"cache_read_price":1.5}`)
+	if legacy == nil || legacy.Tiers[0].CacheReadPrice != nil || legacy.CacheReadPrice == nil || *legacy.CacheReadPrice != 1.5 {
+		t.Fatalf("legacy blob parse broken: %+v", legacy)
+	}
+}
diff --git a/internal/logic/billing/task_billing.go b/internal/logic/billing/task_billing.go
index 7a86b30..0ca22ac 100644
--- a/internal/logic/billing/task_billing.go
+++ b/internal/logic/billing/task_billing.go
@@ -87,8 +87,12 @@ func estimateTaskCost(pricing *PricingResult, ratios map[string]any) decimal.Dec
 			Mul(NewFromFloat(pricing.TenantMultiplier)).
 			Mul(NewFromFloat(effectiveTimeMultiplier(pricing)))
 	case pricing.BillingMode == "per_request":
-		// 按次计费：直接用单价
-		costD = NewFromFloat(pricing.PerRequestPrice)
+		// 按次计费：单价 × 租户乘数 × 时段乘数。与 computeCost / EstimatePreDeductAmount 的
+		// 按次口径对齐——按次任务结算无 token 重算信号，预扣即终价，
+		// 预扣漏乘租户/时段折扣会让折扣租户按原价多扣
+		costD = NewFromFloat(pricing.PerRequestPrice).
+			Mul(NewFromFloat(pricing.TenantMultiplier)).
+			Mul(NewFromFloat(effectiveTimeMultiplier(pricing)))
 	case pricing.OutputPrice > 0 && hasDurationSignal(ratios):
 		duration := 5.0 // 默认 5 秒
 		if d, ok := ratioFloat(ratios, "duration"); ok && d > 0 {
@@ -112,11 +116,14 @@ func estimateTaskCost(pricing *PricingResult, ratios map[string]any) decimal.Dec
 			Mul(NewFromFloat(pricing.OutputPrice)).
 			Mul(NewFromFloat(pricing.TenantMultiplier))
 	default:
-		// 无时长信号（图片等扁平计费任务）：优先按次单价；未配按次价时用占位预扣，
+		// 无时长信号（图片等扁平计费任务）：优先按次单价（同样乘租户/时段乘数，
+		// 预扣即终价的口径与 per_request 分支一致）；未配按次价时用占位预扣，
 		// 绝不走视频 token 估算。结算阶段再按上游真实 token 用量多退少补
 		// （见 sync_image_worker.settleSyncImageSuccess）。
 		if pricing.PerRequestPrice > 0 {
-			costD = NewFromFloat(pricing.PerRequestPrice)
+			costD = NewFromFloat(pricing.PerRequestPrice).
+				Mul(NewFromFloat(pricing.TenantMultiplier)).
+				Mul(NewFromFloat(effectiveTimeMultiplier(pricing)))
 		} else {
 			costD = NewFromFloat(imagePlaceholderPreDeduct)
 		}
diff --git a/internal/logic/billing/task_billing_test.go b/internal/logic/billing/task_billing_test.go
index 757d8aa..5bf17d6 100644
--- a/internal/logic/billing/task_billing_test.go
+++ b/internal/logic/billing/task_billing_test.go
@@ -168,6 +168,38 @@ func TestEstimateTaskCost_PerRequest(t *testing.T) {
 	assertDecimal(t, estimateTaskCost(pricing, nil), 0.04, "per_request cost")
 }
 
+// TestEstimateTaskCost_PerRequestTenantTimeDiscount 按次任务预扣即终价（结算无 token 重算
+// 信号），租户乘数与时段乘数必须在预扣阶段就生效，与 chat 路径 computeCost 的按次口径一致。
+func TestEstimateTaskCost_PerRequestTenantTimeDiscount(t *testing.T) {
+	pricing := &PricingResult{
+		BillingMode:      "per_request",
+		PerRequestPrice:  0.10,
+		TenantMultiplier: 0.5,
+		TimeMultiplier:   0.8,
+	}
+	// 0.10 × 0.5 × 0.8 = 0.04
+	assertDecimal(t, estimateTaskCost(pricing, nil), 0.04, "per_request tenant × time discount")
+
+	// token 模式但仅配按次价的图片任务（default 分支回退）同样生效
+	p2 := &PricingResult{
+		BillingMode:      "token",
+		PerRequestPrice:  0.10,
+		OutputPrice:      30.0,
+		TenantMultiplier: 0.5,
+		TimeMultiplier:   0.8,
+	}
+	assertDecimal(t, estimateTaskCost(p2, nil), 0.04, "image per-request fallback discount")
+
+	// 时段乘数零值（旧缓存条目缺字段）兜底 1.0，不得把预扣清零
+	p3 := &PricingResult{
+		BillingMode:      "per_request",
+		PerRequestPrice:  0.10,
+		TenantMultiplier: 0.5,
+		TimeMultiplier:   0,
+	}
+	assertDecimal(t, estimateTaskCost(p3, nil), 0.05, "zero time multiplier fallback")
+}
+
 // TestEstimateTaskCost_VideoWithDurationSignal 视频任务（ratios 携带 duration/resolution）
 // 才走 10000×duration×resolution 的 token 估算：默认 5s×720p(2.25)×$30/1M = $3.375。
 func TestEstimateTaskCost_VideoWithDurationSignal(t *testing.T) {
diff --git a/web/admin/src/components/ModelPricingModal.vue b/web/admin/src/components/ModelPricingModal.vue
index 81b09c4..6ce2896 100644
--- a/web/admin/src/components/ModelPricingModal.vue
+++ b/web/admin/src/components/ModelPricingModal.vue
@@ -1,9 +1,16 @@
 <script setup lang="ts">
 import { ref, reactive, watch, computed } from 'vue'
 import { Message } from '@arco-design/web-vue'
-import { IconCloudDownload, IconRefresh, IconDelete } from '@arco-design/web-vue/es/icon'
+import { IconCloudDownload, IconRefresh } from '@arco-design/web-vue/es/icon'
 import request from '@/utils/request'
 import { displayCurrency, currencySymbol, formatBilling, cnyToUsd } from '@/composables/useCurrency'
+import PricingTimeSegmentsEditor, {
+	type TimeSegmentRow,
+	type SegmentPreviewBase,
+	timeSegmentRowsFromAPI,
+	timeSegmentPayloadFrom,
+} from './PricingTimeSegmentsEditor.vue'
+import PricingParamRulesEditor, { type ParamRuleRow, paramRuleRowsFromAPI, paramRulePayloadFrom } from './PricingParamRulesEditor.vue'
 
 // 本位币符号：定价输入控件后缀跟随本位币，输入值仍为 bil 层存储原值不折算
 
@@ -81,29 +88,37 @@ function loadPerSecondPrices(prices: Record<string, number> | null | undefined)
 	}
 }
 
-// 行 → 提交 map；返回 null 表示校验失败
-function buildPerSecondPrices(): Record<string, number> | null {
+// 行 → 提交 map；requirePositive=true 要求至少一档正价（计费定价必需，官方参考价不强制）。
+// map 为 null 表示校验失败（error 为中文提示文案）
+function buildPerSecondMap(rows: PerSecondRow[], requirePositive: boolean): { map: Record<string, number> | null; error?: string } {
 	const map: Record<string, number> = {}
 	let hasPositive = false
-	for (const row of perSecondRows) {
+	for (const row of rows) {
 		const spec = row.spec.trim()
 		if (!spec) continue
 		if (map[spec] !== undefined) {
-			Message.warning(`按秒计费规格「${spec}」重复`)
-			return null
+			return { map: null, error: `按秒计费规格「${spec}」重复` }
 		}
 		if (row.price < 0) {
-			Message.warning(`按秒计费规格「${spec}」单价不能为负`)
-			return null
+			return { map: null, error: `按秒计费规格「${spec}」单价不能为负` }
 		}
 		map[spec] = row.price
 		if (row.price > 0) hasPositive = true
 	}
-	if (!hasPositive) {
-		Message.warning('按秒计费至少配置一档正价（建议额外配置 * 兜底价）')
+	if (requirePositive && !hasPositive) {
+		return { map: null, error: '按秒计费至少配置一档正价（建议额外配置 * 兜底价）' }
+	}
+	return { map }
+}
+
+// 主定价按秒矩阵：校验失败 Message 提示并返回 null
+function buildPerSecondPrices(): Record<string, number> | null {
+	const result = buildPerSecondMap(perSecondRows, true)
+	if (result.map === null) {
+		if (result.error) Message.warning(result.error)
 		return null
 	}
-	return map
+	return result.map
 }
 
 // 时段预览基准价：优先 * 兜底价，否则矩阵最低正价
@@ -120,20 +135,23 @@ function resetEditorDefaults() {
 	editorItems.push(createEmptyItem('token'))
 	perSecondRows.length = 0
 	paramRules.length = 0
-	tryMatchInput.value = ''
+	editorTimeSegments.length = 0
+	timePricingEnabled.value = false
+	paramEditorRef.value?.resetParamRules()
 	editorPriceNote.value = ''
 	editorDiscountLabel.value = ''
 	editorPriceChangeNote.value = ''
-	resetTimeSegments()
+	resetOfficialPricing()
+	officialDiscountPercent.value = 100
 }
 
 // ============================================================
-// Official Pricing Fetch
+// Official Pricing Fetch（数据源参考价：官方价二层弹窗内懒加载）
 // ============================================================
 const officialLoading = ref(false)
 const officialData = ref<any>(null)
 const officialError = ref('')
-const officialPricingVisible = ref(false)
+const officialModalVisible = ref(false)
 
 const officialSourceMeta: Record<string, { label: string; color: string }> = {
 	litellm: { label: 'LiteLLM', color: 'arcoblue' },
@@ -152,11 +170,16 @@ const usdToBaseRatio = computed(() => {
 	return 1 / cnyToUsd.value
 })
 
-// USD 原值 → 本位币值（4 位小数，与定价输入控件精度对齐）
+// USD 原值 → 本位币值（6 位小数，与资金显示精度及定价输入控件精度对齐）
 function toBasePrice(v: number | null | undefined): number {
 	const usd = Number(v ?? 0)
 	if (usd <= 0) return 0
-	return Math.round(usd * usdToBaseRatio.value * 10000) / 10000
+	return Math.round(usd * usdToBaseRatio.value * 1e6) / 1e6
+}
+
+// 金额按 6 位小数取整（折扣计算结果落编辑器前的唯一取整点）
+function round6(v: number): number {
+	return Math.round(v * 1e6) / 1e6
 }
 
 // 官方参考价展示：折算为本位币直显；本位币=CNY 时括注美元原值便于核对
@@ -170,11 +193,17 @@ function formatOfficialPrice(v: number | null | undefined): string {
 function resetOfficialData() {
 	officialData.value = null
 	officialError.value = ''
-	officialPricingVisible.value = false
+	officialModalVisible.value = false
 }
 
-function handleOfficialPricingVisibleChange(visible: boolean) {
-	officialPricingVisible.value = visible
+// 打开官方价二层弹窗：数据源不自动拉取，用户在弹窗内按需展开（后端串行请求 4 个源，冷缓存较慢）
+function openOfficialModal() {
+	officialModalVisible.value = true
+}
+
+// 数据源参考价浮窗（APopover 挂在标题行按钮上）：trigger=click 非受控，
+// 首次弹出自动拉取；已拉取过则直接展示
+function onSourcesVisibleChange(visible: boolean) {
 	if (visible && !officialData.value && !officialLoading.value) {
 		fetchOfficialPricing()
 	}
@@ -195,231 +224,519 @@ async function fetchOfficialPricing() {
 	}
 }
 
-function applyOfficialPricing(pricing: any) {
-	if (!pricing) return
-	if (editorItems.length > 0) {
-		// 编辑表单按本位币原值输入，官方 USD 价格须先折算为本位币
-		editorItems[0].input_price = toBasePrice(pricing.input_price)
-		editorItems[0].output_price = toBasePrice(pricing.output_price)
-		editorItems[0].cache_read_price = toBasePrice(pricing.cache_read_price)
-		editorItems[0].cache_creation_price = toBasePrice(pricing.cache_creation_price)
-	}
-	if (pricing.billing_mode && pricing.billing_mode !== editorBillingMode.value) {
-		editorBillingMode.value = pricing.billing_mode
-	}
-	officialPricingVisible.value = false
-	Message.success('已填入官方参考定价')
-}
-
 // ============================================================
-// Param Multipliers（参数倍率：按归一化任务体参数匹配，命中规则连乘）
+// 官方定价（official_pricing 落库参照：非计费依据，是折扣计算与几折展示的基准）。
+// 存储结构与计费定价完全同构（official_items + 时段 + 参数倍率，支持全部四种计费模式）；
+// 数据源拉取仅作平面价初值参考，人工核对修正后随保存落库，调折扣不再依赖远程数据源
 // ============================================================
-interface ParamConditionRow {
-	path: string
-	match: string // has_value | equals | gt | gte | lt | lte | between
-	value: string // 输入态字符串；between 逗号分隔；提交时按匹配方式转换
-}
-interface ParamRuleRow {
-	conditions: ParamConditionRow[]
-	multiplier: number
-	note: string
-}
+const officialBillingMode = ref('token')
+const officialItems = reactive<any[]>([])
+const officialPerSecondRows = reactive<PerSecondRow[]>([])
+const officialTimeSegments = reactive<TimeSegmentRow[]>([])
+const officialTimeEnabled = ref(false)
+const officialParamRules = reactive<ParamRuleRow[]>([])
+// 官方时段/倍率的回显与载荷一律走纯函数填充/构建行数组，不依赖编辑器组件挂载
+// （编辑器在二层弹窗内，Arco Modal 关闭即卸载，ref 不可靠）
 
-const paramRules = reactive<ParamRuleRow[]>([])
-
-const paramMatchOptions = [
-	{ label: '有值', value: 'has_value' },
-	{ label: '等于', value: 'equals' },
-	{ label: '大于', value: 'gt' },
-	{ label: '大于等于', value: 'gte' },
-	{ label: '小于', value: 'lt' },
-	{ label: '小于等于', value: 'lte' },
-	{ label: '区间', value: 'between' },
+const officialBillingModeOptions = [
+	{ label: '按量 (Token)', value: 'token' },
+	{ label: '按次', value: 'per_request' },
+	{ label: '阶梯计费', value: 'tiered' },
+	{ label: '按秒', value: 'per_second' },
 ]
 
-// 常用路径预设（归一化任务体，规则跟语义走不跟入口协议走）
-const paramPathPresets = [
-	'metadata.image',
-	'metadata.duration',
-	'metadata.resolution',
-	'metadata.aspect_ratio',
-	'seconds',
-	'metadata.content[*].video_url',
-	'metadata.content[*].role',
-]
-
-function addParamRule() {
-	paramRules.push({ conditions: [{ path: '', match: 'has_value', value: '' }], multiplier: 1, note: '' })
+// 官方定价首行（单行模式取价用；tiered 的档位价在 officialItems 各行）
+function officialFirst(): any {
+	return officialItems[0] || {}
 }
 
-function removeParamRule(index: number) {
-	paramRules.splice(index, 1)
-}
-
-function addParamCondition(ruleIndex: number) {
-	paramRules[ruleIndex].conditions.push({ path: '', match: 'has_value', value: '' })
-}
-
-function removeParamCondition(ruleIndex: number, condIndex: number) {
-	paramRules[ruleIndex].conditions.splice(condIndex, 1)
-}
-
-function conditionNeedsValue(match: string): boolean {
-	return match !== 'has_value'
-}
-
-// 条件输入态 → 提交值（数字类强转、between 转双元素数组、equals 保原样）
-function conditionValuePayload(cond: ParamConditionRow): any {
-	const raw = cond.value.trim()
-	if (cond.match === 'between') {
-		const parts = raw.split(',').map((s) => s.trim()).filter(Boolean)
-		return parts.length === 2 ? parts.map(Number) : null
+// 官方定价是否已配置（价格维度或时段/倍率任一非空；阶梯看任一档——首档可能是 0 价免费档）
+const hasOfficialPricing = computed(() => {
+	if (officialTimeSegments.length > 0 || officialParamRules.length > 0) return true
+	if (officialBillingMode.value === 'tiered') {
+		return officialItems.some(
+			(t) =>
+				(Number(t.input_price) || 0) > 0 ||
+				(Number(t.output_price) || 0) > 0 ||
+				(Number(t.cache_read_price) || 0) > 0 ||
+				(Number(t.cache_creation_price) || 0) > 0,
+		)
 	}
-	if (['gt', 'gte', 'lt', 'lte'].includes(cond.match)) {
-		const n = Number(raw)
-		return raw !== '' && !Number.isNaN(n) ? n : null
-	}
-	return raw // equals：字符串原样（后端数字强转比较）
+	const first = officialFirst()
+	return (
+		Number(first.input_price) > 0 ||
+		Number(first.output_price) > 0 ||
+		Number(first.cache_read_price) > 0 ||
+		Number(first.cache_creation_price) > 0 ||
+		(Number(first.per_request_price) || 0) > 0 ||
+		officialPerSecondRows.some((r) => (Number(r.price) || 0) > 0)
+	)
+})
+
+function addOfficialPerSecondRow(spec = '') {
+	officialPerSecondRows.push({ spec, price: 0 })
 }
 
-// 行编辑态 → 提交载荷；校验失败返回 null
-function buildParamMultipliersPayload(): any[] | null {
-	const payload: any[] = []
-	for (const [i, rule] of paramRules.entries()) {
-		if (rule.multiplier <= 0 || rule.multiplier > 100) {
-			Message.warning(`参数倍率规则 ${i + 1} 倍率需在 (0, 100] 区间`)
-			return null
+function removeOfficialPerSecondRow(index: number) {
+	officialPerSecondRows.splice(index, 1)
+}
+
+// 保证官方定价首行存在：模板直接绑定 officialItems[0]，空数组会渲染报错；
+// 空行（价格全 0）不视为已配置，提交时后端按全空清除，无害
+function ensureOfficialFirstRow(mode = officialBillingMode.value) {
+	if (officialItems.length === 0) {
+		officialItems.push({ billing_mode: mode, min_tokens: 0, max_tokens: null, input_price: 0, output_price: 0, per_request_price: null, cache_read_price: 0, cache_creation_price: 0, per_second_prices: null })
+	}
+}
+
+// 切换官方计费模式时保证首行存在且行数合法（保留原首行价格，tiered 之外不保留多余档位行）
+watch(officialBillingMode, (mode) => {
+	ensureOfficialFirstRow(mode)
+	if (mode !== 'tiered' && officialItems.length > 1) {
+		officialItems.splice(1)
+	}
+	officialItems[0].billing_mode = mode
+	// 切到按秒模式时给常见起始模板（与主编辑器一致，已手动填写则不覆盖）
+	if (mode === 'per_second' && officialPerSecondRows.length === 0) {
+		addOfficialPerSecondRow('720p')
+		addOfficialPerSecondRow('*')
+	}
+})
+
+// 组件创建即补首行（定价弹窗在模型列表页常驻渲染，此时 loadPricing 尚未执行）
+ensureOfficialFirstRow()
+
+function addOfficialTier() {
+	// 阶梯档位行：上一档 max_tokens 收口为新增档的 min_tokens（与主弹窗阶梯语义一致）
+	const last = officialItems[officialItems.length - 1]
+	if (last && last.max_tokens != null) {
+		const nextMin = Number(last.max_tokens) + 1
+		last.max_tokens = nextMin - 1
+		officialItems.push({ billing_mode: 'tiered', min_tokens: nextMin, max_tokens: null, input_price: 0, output_price: 0, per_request_price: null, cache_read_price: 0, cache_creation_price: 0, per_second_prices: null })
+	} else {
+		officialItems.push({ billing_mode: 'tiered', min_tokens: 0, max_tokens: null, input_price: 0, output_price: 0, per_request_price: null, cache_read_price: 0, cache_creation_price: 0, per_second_prices: null })
+	}
+}
+
+function removeOfficialTier(index: number) {
+	if (officialItems.length <= 1) return
+	officialItems.splice(index, 1)
+	// 末档保持无上限
+	if (officialItems.length > 0) officialItems[officialItems.length - 1].max_tokens = null
+}
+
+// 回显：GET pricing 响应 → 官方定价编辑器（official_items + 时段 + 倍率，同构结构）。
+// 时段/倍率用纯函数直接填充行数组——二层弹窗未打开时编辑器组件未挂载，ref 加载不生效
+function loadOfficialPricing(data: any) {
+	officialBillingMode.value = 'token'
+	officialItems.length = 0
+	officialPerSecondRows.length = 0
+	const list: any[] = data?.official_items || []
+	if (list.length > 0) {
+		officialBillingMode.value = list[0].billing_mode || 'token'
+		for (const item of list) {
+			officialItems.push({
+				billing_mode: item.billing_mode,
+				min_tokens: item.min_tokens || 0,
+				max_tokens: item.max_tokens ?? null,
+				input_price: item.input_price ?? 0,
+				output_price: item.output_price ?? 0,
+				per_request_price: item.per_request_price ?? null,
+				cache_read_price: item.cache_read_price ?? 0,
+				cache_creation_price: item.cache_creation_price ?? 0,
+				per_second_prices: item.per_second_prices ?? null,
+			})
 		}
-		if (rule.conditions.length === 0) {
-			Message.warning(`参数倍率规则 ${i + 1} 至少需要一个条件`)
-			return null
+		const perSecond: Record<string, number> = list[0].per_second_prices || {}
+		for (const [spec, price] of Object.entries(perSecond)) {
+			officialPerSecondRows.push({ spec, price: Number(price) || 0 })
 		}
-		const conditions: any[] = []
-		for (const [j, cond] of rule.conditions.entries()) {
-			const path = cond.path.trim()
-			if (!path) {
-				Message.warning(`参数倍率规则 ${i + 1} 条件 ${j + 1} 路径为空`)
-				return null
-			}
-			const value = conditionValuePayload(cond)
-			if (conditionNeedsValue(cond.match) && (value === null || value === '')) {
-				Message.warning(`参数倍率规则 ${i + 1} 条件 ${j + 1} 需要填写比对值`)
-				return null
-			}
-			conditions.push(conditionNeedsValue(cond.match) ? { path, match: cond.match, value } : { path, match: cond.match })
-		}
-		// 命中说明：空 = 默认「规则N」（随序号，删除上方规则后自动顺延）
-		payload.push({ conditions, multiplier: rule.multiplier, note: rule.note.trim() || `规则 ${i + 1}` })
+	} else {
+		// 无官方价：补一行空 token 行，保证官方编辑器模板绑定 officialItems[0] 安全
+		ensureOfficialFirstRow()
 	}
-	return payload
+	const segConv = timeSegmentRowsFromAPI(data?.official_time_segments)
+	officialTimeSegments.length = 0
+	officialTimeSegments.push(...segConv.rows)
+	officialTimeEnabled.value = segConv.enabled
+	const ruleRows = paramRuleRowsFromAPI(data?.official_param_multipliers)
+	officialParamRules.length = 0
+	officialParamRules.push(...ruleRows)
 }
 
-// 回显：后端规则 → 行编辑态
-function loadParamMultipliers(list: any[] | null | undefined) {
-	paramRules.length = 0
-	if (!Array.isArray(list)) return
-	for (const rule of list) {
-		const row: ParamRuleRow = {
-			conditions: (rule.conditions || []).map((c: any) => ({
-				path: c.path || '',
-				match: c.match || 'has_value',
-				value: Array.isArray(c.value) ? c.value.join(',') : c.value != null ? String(c.value) : '',
-			})),
-			multiplier: Number(rule.multiplier) || 1,
-			note: rule.note || '',
-		}
-		if (row.conditions.length > 0) paramRules.push(row)
-	}
+function resetOfficialPricing() {
+	officialBillingMode.value = 'token'
+	officialItems.length = 0
+	officialPerSecondRows.length = 0
+	officialTimeSegments.length = 0
+	officialTimeEnabled.value = false
+	officialParamRules.length = 0
+	ensureOfficialFirstRow()
 }
 
-// ── 试匹配预览（前端复刻后端求值语义：路径提取 + [*] 扇出 + 数字强转 + 隐式与 + 连乘） ──
-const tryMatchInput = ref('')
-
-function lookupPath(root: any, path: string): { values: any[]; found: boolean } {
-	const segments = path.split('.').filter(Boolean)
-	let current = [root]
-	for (const seg of segments) {
-		const wildcard = seg.endsWith('[*]')
-		const key = wildcard ? seg.slice(0, -3) : seg
-		const next: any[] = []
-		for (const cur of current) {
-			if (cur == null || typeof cur !== 'object' || Array.isArray(cur)) continue
-			const v = (cur as Record<string, any>)[key]
-			if (v === undefined) continue
-			if (wildcard) {
-				if (Array.isArray(v)) next.push(...v)
-			} else {
-				next.push(v)
-			}
-		}
-		if (next.length === 0) return { values: [], found: false }
-		current = next
-	}
-	return { values: current, found: true }
+// 保存载荷：官方定价 → official_items / official_time_segments / official_param_multipliers
+// 三个数组恒传（后端 OfficialItems nil 才是「不动」），与主定价同为全量替换语义
+function officialItemsPayload(): any[] {
+	return officialItems.map((item, index) => ({
+		billing_mode: officialBillingMode.value,
+		min_tokens: officialBillingMode.value === 'tiered' ? item.min_tokens : 0,
+		max_tokens: officialBillingMode.value === 'tiered' ? (index < officialItems.length - 1 ? item.max_tokens : null) : null,
+		input_price: item.input_price,
+		output_price: item.output_price,
+		per_request_price: officialBillingMode.value === 'per_request' ? (item.per_request_price ?? null) : null,
+		cache_read_price: item.cache_read_price,
+		cache_creation_price: item.cache_creation_price,
+		per_second_prices: officialBillingMode.value === 'per_second' ? officialPerSecondPayload() : null,
+	}))
 }
 
-function toNum(v: any): number | null {
-	if (typeof v === 'number') return v
-	if (typeof v === 'string' && v.trim() !== '' && !Number.isNaN(Number(v))) return Number(v)
-	return null
+function officialPerSecondPayload(): Record<string, number> {
+	const prices: Record<string, number> = {}
+	for (const row of officialPerSecondRows) {
+		const spec = row.spec.trim()
+		if (spec) prices[spec] = Number(row.price) || 0
+	}
+	return prices
 }
 
-function conditionHit(cond: { path: string; match: string; value?: any }, root: any): boolean {
-	const { values, found } = lookupPath(root, cond.path)
-	if (!found) return false
-	if (cond.match === 'has_value') return values.some((v) => v !== null && v !== undefined)
-	const target = Array.isArray(cond.value) ? cond.value.map(Number) : cond.value
-	if (cond.match === 'equals') {
-		return values.some((v) => {
-			const vn = toNum(v)
-			const tn = toNum(target)
-			if (vn != null && tn != null) return vn === tn
-			return v === target
-		})
-	}
-	if (cond.match === 'between') {
-		if (!Array.isArray(target) || target.length !== 2) return false
-		return values.some((v) => {
-			const n = toNum(v)
-			return n != null && n >= target[0] && n <= target[1]
-		})
-	}
-	const tn = toNum(target)
-	if (tn == null) return false
-	return values.some((v) => {
-		const n = toNum(v)
-		if (n == null) return false
-		if (cond.match === 'gt') return n > tn
-		if (cond.match === 'gte') return n >= tn
-		if (cond.match === 'lt') return n < tn
-		return n <= tn // lte
-	})
-}
-
-// 试匹配结果：命中规则列表 + 总倍率
-function tryMatchResult(): { hits: Array<{ label: string; multiplier: number }>; total: number } | null {
-	const raw = tryMatchInput.value.trim()
-	if (!raw) return null
-	let root: any
-	try {
-		root = JSON.parse(raw)
-	} catch {
+// 官方时段载荷：从行数组纯函数构建（不依赖编辑器挂载）；null=校验失败，调用方中止保存
+function officialTimeSegmentsPayload(): any[] | null {
+	const result = timeSegmentPayloadFrom(officialTimeSegments, officialTimeEnabled.value)
+	if (result.error) {
+		Message.warning(result.error)
 		return null
 	}
-	const hits: Array<{ label: string; multiplier: number }> = []
-	let total = 1
-	for (const rule of paramRules) {
-		const allHit = rule.conditions.every((c) =>
-			conditionHit({ path: c.path, match: c.match, value: conditionValuePayload(c) }, root),
-		)
-		if (allHit) {
-			total *= rule.multiplier || 1
-			hits.push({ label: rule.note || rule.conditions.map((c) => c.path).join(' & '), multiplier: rule.multiplier })
-		}
-	}
-	return { hits, total }
+	return result.payload ?? []
 }
 
+// 官方参数倍率载荷：同官方时段，null=校验失败
+function officialParamRulesPayload(): any[] | null {
+	const result = paramRulePayloadFrom(officialParamRules)
+	if (result.error) {
+		Message.warning(result.error)
+		return null
+	}
+	return result.payload ?? []
+}
+
+// 数据源源价 → 官方定价编辑器（100% 填入，USD 折算本位币 6 位小数；数据源只有平面价，
+// 填入后仅改价格初值，人工核对修正并保存才落库）
+function applySourceToOfficial(pricing: any) {
+	if (!pricing) return
+	if (officialBillingMode.value === 'per_second') {
+		Message.warning('官方定价当前为按秒模式，数据源无按秒价格，请手动填写')
+		return
+	}
+	if (officialBillingMode.value === 'tiered') {
+		Message.warning('官方定价当前为阶梯模式，数据源为平面价，请手动调整各档位')
+		return
+	}
+	if (officialItems.length === 0) {
+		officialItems.push({ billing_mode: officialBillingMode.value, min_tokens: 0, max_tokens: null, input_price: 0, output_price: 0, per_request_price: null, cache_read_price: 0, cache_creation_price: 0, per_second_prices: null })
+	}
+	const first = officialItems[0]
+	if (pricing.billing_mode === 'per_request') {
+		officialBillingMode.value = 'per_request'
+		first.per_request_price = toBasePrice(pricing.output_price)
+	} else {
+		if (officialBillingMode.value === 'per_request') {
+			officialBillingMode.value = 'token'
+		}
+		first.input_price = toBasePrice(pricing.input_price)
+		first.output_price = toBasePrice(pricing.output_price)
+		first.cache_read_price = toBasePrice(pricing.cache_read_price)
+		first.cache_creation_price = toBasePrice(pricing.cache_creation_price)
+	}
+	Message.success('已采用该数据源价格作为官方定价，请人工核对修正后保存')
+}
+
+// 派生比较：数据源价（USD）折本位币后与当前基准完全一致 → 该源即当前基准的来源
+// （official_pricing 落库不存来源字段，只能前端比对推导；仅平面价模式可比）
+function isCurrentBaseline(src: any): boolean {
+	const p = src?.pricing
+	if (!src?.found || !p) return false
+	const first = officialFirst()
+	if (p.billing_mode === 'per_request') {
+		return (
+			officialBillingMode.value === 'per_request' &&
+			(Number(first.per_request_price) || 0) > 0 &&
+			round6(toBasePrice(p.output_price)) === round6(Number(first.per_request_price) || 0)
+		)
+	}
+	if (officialBillingMode.value !== 'token') return false
+	return (
+		round6(toBasePrice(p.input_price)) === round6(Number(first.input_price) || 0) &&
+		round6(toBasePrice(p.output_price)) === round6(Number(first.output_price) || 0) &&
+		round6(toBasePrice(p.cache_read_price)) === round6(Number(first.cache_read_price) || 0) &&
+		round6(toBasePrice(p.cache_creation_price)) === round6(Number(first.cache_creation_price) || 0)
+	)
+}
+
+// 按折扣换算（百分比）：官方定价 × 折扣 → 整体替换我方定价（价格维度 ×折扣，
+// 时段与参数倍率原样复制——乘数是相对结构，不随折扣缩放）。纯前端计算，保留 6 位小数
+const officialDiscountPercent = ref(100)
+
+// 折扣显示文案：88.5% → "8.85 折"、50% → "5 折"
+function foldLabel(percent: number | null | undefined): string {
+	const p = Number(percent) || 0
+	return String(+(p / 10).toFixed(2))
+}
+
+interface OfficialApplyRow {
+	label: string
+	official: number
+	applied: number
+	current: number
+}
+
+interface OfficialApplyPlan {
+	ok: boolean
+	reason: string // 不满足时的中文原因（预览区展示 + 按钮 disabled）
+	hint: string // 可换算时的作用范围提示
+	rows: OfficialApplyRow[]
+	timeSegmentCount: number // 将原样复制的时段条数
+	paramRuleCount: number // 将原样复制的参数倍率条数
+	target: 'token' | 'per_request' | 'tiered' | 'per_second' // 将写入的我方计费模式
+	tiers: Array<{ min_tokens: number; max_tokens: number | null; input_price: number; output_price: number; cache_read_price: number; cache_creation_price: number }> // tiered 换算结果
+}
+
+// 换算计划：预览表与执行动作共用同一套判断与计算，避免两份逻辑漂移
+function officialApplyPlan(): OfficialApplyPlan {
+	const plan: OfficialApplyPlan = { ok: false, reason: '', hint: '', rows: [], timeSegmentCount: 0, paramRuleCount: 0, target: 'token', tiers: [] }
+	if (!hasOfficialPricing.value) {
+		plan.reason = '官方定价尚未配置，请先从数据源采用或手动填写'
+		return plan
+	}
+	const percent = Number(officialDiscountPercent.value)
+	if (!percent || percent <= 0) {
+		plan.reason = '请填写有效的折扣'
+		return plan
+	}
+	const d = percent / 100
+	const mode = officialBillingMode.value
+	plan.target = mode as OfficialApplyPlan['target']
+	if (editorBillingMode.value === 'per_second' && mode !== 'per_second') {
+		plan.reason = '当前计费为按秒模式，官方定价需同为按秒才能换算填入'
+		return plan
+	}
+	const first: any = editorItems[0] || {}
+	const offFirst: any = officialFirst()
+	if (mode === 'per_second') {
+		// 官方按秒矩阵 × 折扣 → 整体替换我方矩阵（规格随官方定价）
+		for (const r of officialPerSecondRows) {
+			const spec = r.spec.trim()
+			if (!spec) continue
+			const official = Number(r.price) || 0
+			plan.rows.push({
+				label: spec,
+				official,
+				applied: round6(official * d),
+				current: perSecondRows.find((c) => c.spec.trim() === spec)?.price || 0,
+			})
+		}
+		if (!plan.rows.some((r) => r.applied > 0)) {
+			plan.reason = '官方按秒定价矩阵中没有正价规格'
+			return plan
+		}
+		plan.hint = '将整体替换我方按秒规格矩阵（规格随官方定价）'
+	} else if (mode === 'per_request') {
+		const official = Number(offFirst.per_request_price) || 0
+		plan.rows.push({
+			label: '按次单价',
+			official,
+			applied: round6(official * d),
+			current: Number(first.per_request_price) || 0,
+		})
+		if (plan.rows[0].applied <= 0) {
+			plan.reason = '官方按次定价尚未配置单价'
+			return plan
+		}
+		plan.hint = '将整体替换我方按次单价'
+	} else if (mode === 'tiered') {
+		// 阶梯：逐档 input/output/缓存价 ×折扣，整体重建我方阶梯
+		for (const [i, t] of officialItems.entries()) {
+			const officialIn = Number(t.input_price) || 0
+			const officialOut = Number(t.output_price) || 0
+			const officialCacheRead = Number(t.cache_read_price) || 0
+			const officialCacheCreation = Number(t.cache_creation_price) || 0
+			plan.rows.push({
+				label: `档位 ${i + 1}（≥${Number(t.min_tokens) || 0} tokens）`,
+				official: officialIn,
+				applied: round6(officialIn * d),
+				current: Number(editorItems[i]?.input_price) || 0,
+			})
+			plan.rows.push({
+				label: `档位 ${i + 1} 输出`,
+				official: officialOut,
+				applied: round6(officialOut * d),
+				current: Number(editorItems[i]?.output_price) || 0,
+			})
+			if (officialCacheRead > 0) {
+				plan.rows.push({
+					label: `档位 ${i + 1} 缓存读取`,
+					official: officialCacheRead,
+					applied: round6(officialCacheRead * d),
+					current: Number(editorItems[i]?.cache_read_price) || 0,
+				})
+			}
+			if (officialCacheCreation > 0) {
+				plan.rows.push({
+					label: `档位 ${i + 1} 缓存创建`,
+					official: officialCacheCreation,
+					applied: round6(officialCacheCreation * d),
+					current: Number(editorItems[i]?.cache_creation_price) || 0,
+				})
+			}
+			plan.tiers.push({
+				min_tokens: Number(t.min_tokens) || 0,
+				max_tokens: i < officialItems.length - 1 ? (t.max_tokens ?? null) : null,
+				input_price: round6(officialIn * d),
+				output_price: round6(officialOut * d),
+				cache_read_price: round6(officialCacheRead * d),
+				cache_creation_price: round6(officialCacheCreation * d),
+			})
+		}
+		if (!plan.tiers.some((t) => t.input_price > 0 || t.output_price > 0)) {
+			plan.reason = '官方阶梯定价中没有任何正价档位'
+			return plan
+		}
+		plan.hint = '将按官方档位整体重建我方阶梯定价（逐档缓存价 ×折扣）'
+	} else {
+		plan.target = 'token'
+		const dims: Array<[string, number, number]> = [
+			['输入价格', Number(offFirst.input_price) || 0, Number(first.input_price) || 0],
+			['输出价格', Number(offFirst.output_price) || 0, Number(first.output_price) || 0],
+			['缓存读取', Number(offFirst.cache_read_price) || 0, Number(first.cache_read_price) || 0],
+			['缓存创建', Number(offFirst.cache_creation_price) || 0, Number(first.cache_creation_price) || 0],
+		]
+		for (const [label, official, current] of dims) {
+			plan.rows.push({ label, official, applied: round6(official * d), current })
+		}
+		if (!plan.rows.some((r) => r.applied > 0)) {
+			plan.reason = '官方定价尚未配置价格'
+			return plan
+		}
+		plan.hint = '将覆盖我方按量四项价格，保留 6 位小数'
+	}
+	// 时段与参数倍率原样复制（乘数是相对结构，不随折扣缩放）
+	plan.timeSegmentCount = officialTimeEnabled.value ? officialTimeSegments.length : 0
+	plan.paramRuleCount = officialParamRules.length
+	if (plan.timeSegmentCount > 0 || plan.paramRuleCount > 0) {
+		plan.hint += `；另将原样复制官方的 ${plan.timeSegmentCount} 条时段定价与 ${plan.paramRuleCount} 条参数倍率规则`
+	}
+	plan.ok = true
+	return plan
+}
+
+function applyOfficialToPricing() {
+	const plan = officialApplyPlan()
+	if (!plan.ok) {
+		Message.warning(plan.reason)
+		return
+	}
+	if (plan.target === 'per_second') {
+		editorBillingMode.value = 'per_second'
+		perSecondRows.length = 0
+		perSecondRows.push(...plan.rows.map((r) => ({ spec: r.label, price: r.applied })))
+	} else if (plan.target === 'per_request') {
+		editorBillingMode.value = 'per_request'
+		if (editorItems.length === 0) {
+			editorItems.push(createEmptyItem('per_request'))
+		}
+		editorItems.splice(1)
+		editorItems[0].per_request_price = plan.rows[0].applied
+	} else if (plan.target === 'tiered') {
+		editorBillingMode.value = 'tiered'
+		editorItems.length = 0
+		for (const t of plan.tiers) {
+			editorItems.push({
+				billing_mode: 'tiered',
+				min_tokens: t.min_tokens,
+				max_tokens: t.max_tokens,
+				input_price: t.input_price,
+				output_price: t.output_price,
+				per_request_price: null,
+				cache_read_price: t.cache_read_price,
+				cache_creation_price: t.cache_creation_price,
+				per_second_prices: null,
+			})
+		}
+	} else {
+		if (editorBillingMode.value === 'per_request') {
+			editorBillingMode.value = 'token'
+		}
+		if (editorItems.length === 0) {
+			editorItems.push(createEmptyItem('token'))
+		}
+		editorItems.splice(1)
+		editorItems[0].input_price = plan.rows[0].applied
+		editorItems[0].output_price = plan.rows[1].applied
+		editorItems[0].cache_read_price = plan.rows[2].applied
+		editorItems[0].cache_creation_price = plan.rows[3].applied
+	}
+	// 时段与参数倍率整体复制（直接克隆行数据，不经载荷往返；乘数是相对结构，不随折扣缩放）
+	if (plan.timeSegmentCount > 0) {
+		editorTimeSegments.length = 0
+		editorTimeSegments.push(
+			...officialTimeSegments.map((s) => ({
+				...s,
+				days: [...s.days],
+				validRange: s.validRange ? [...s.validRange] : undefined,
+			})),
+		)
+		timePricingEnabled.value = true
+	}
+	if (plan.paramRuleCount > 0) {
+		paramRules.length = 0
+		paramRules.push(...officialParamRules.map((r) => ({ ...r, conditions: r.conditions.map((c) => ({ ...c })) })))
+	}
+	Message.success(`已按官方价 ${foldLabel(Number(officialDiscountPercent.value))} 折填入（整体替换我方定价）`)
+}
+
+// 现价相对库内官方价的折扣摘要（营销口径自动计算，替代手算几折）。
+// 官方与计费模式需同维可比（token↔token/tiered 取输入输出、按次↔按次、按秒↔按秒取基准价）
+function foldText(officialVal: number, currentVal: number): string | null {
+	if (officialVal <= 0 || currentVal <= 0) return null
+	return String(+((currentVal / officialVal) * 10).toFixed(2))
+}
+
+function officialPerSecondBasePrice(): number {
+	const prices = officialPerSecondRows.map((r) => Number(r.price) || 0).filter((p) => p > 0)
+	if (prices.length === 0) return 0
+	const wildcard = officialPerSecondRows.find((r) => r.spec.trim() === '*')
+	return wildcard && wildcard.price > 0 ? wildcard.price : Math.min(...prices)
+}
+
+function officialFoldSummary(): string | null {
+	const first: any = editorItems[0] || {}
+	const offFirst: any = officialFirst()
+	const parts: string[] = []
+	if (officialBillingMode.value === 'per_second' && editorBillingMode.value === 'per_second') {
+		const fold = foldText(officialPerSecondBasePrice(), perSecondBasePrice())
+		if (fold) parts.push(`单价 ${fold} 折`)
+	} else if (officialBillingMode.value === 'per_request' && editorBillingMode.value === 'per_request') {
+		const fold = foldText(Number(offFirst.per_request_price) || 0, Number(first.per_request_price) || 0)
+		if (fold) parts.push(`单价 ${fold} 折`)
+	} else if (officialBillingMode.value === 'tiered' && editorBillingMode.value === 'tiered') {
+		// 阶梯对阶梯：取首档（min_tokens=0）输入价比较
+		const offEntry = officialItems.find((t: any) => (Number(t.min_tokens) || 0) === 0) || officialItems[0] || {}
+		const fold = foldText(Number(offEntry.input_price) || 0, Number(first.input_price) || 0)
+		if (fold) parts.push(`首档 ${fold} 折`)
+	} else if (officialBillingMode.value === 'token' && (editorBillingMode.value === 'token' || editorBillingMode.value === 'tiered')) {
+		const fi = foldText(Number(offFirst.input_price) || 0, Number(first.input_price) || 0)
+		const fo = foldText(Number(offFirst.output_price) || 0, Number(first.output_price) || 0)
+		if (fi) parts.push(`输入 ${fi} 折`)
+		if (fo) parts.push(`输出 ${fo} 折`)
+	}
+	return parts.length ? parts.join(' · ') : null
+}
+
+// ============================================================
+// Param Multipliers（参数倍率：行数据父级持有，编辑/校验/载荷在 PricingParamRulesEditor 组件）
+// ============================================================
+const paramRules = reactive<ParamRuleRow[]>([])
+const paramEditorRef = ref<InstanceType<typeof PricingParamRulesEditor>>()
+
 // ============================================================
 // Load Pricing Data
 // ============================================================
@@ -428,7 +745,6 @@ async function loadPricing() {
 	editorItems.length = 0
 	editorBillingMode.value = 'token'
 	paramRules.length = 0
-	tryMatchInput.value = ''
 	resetOfficialData()
 	editorLoading.value = true
 
@@ -458,8 +774,9 @@ async function loadPricing() {
 		} else {
 			resetEditorDefaults()
 		}
-		loadTimeSegments(res.data?.data?.time_segments)
-		loadParamMultipliers(res.data?.data?.param_multipliers)
+		timeSegEditorRef.value?.loadTimeSegments(res.data?.data?.time_segments)
+		paramEditorRef.value?.loadParamMultipliers(res.data?.data?.param_multipliers)
+		loadOfficialPricing(res.data?.data)
 	} catch {
 		resetEditorDefaults()
 	} finally {
@@ -468,165 +785,37 @@ async function loadPricing() {
 }
 
 // ============================================================
-// Time Segment Pricing Editor（时段定价：按命名时段对全部价格等比缩放）
+// Time Segment Pricing Editor（时段定价：行数据父级持有，编辑/校验/载荷在 PricingTimeSegmentsEditor 组件）
 // ============================================================
-interface TimeSegmentRow {
-	name: string
-	dayPreset: string // every / weekday / weekend / custom
-	days: number[] // 仅 custom 使用，1=周一..7=周日
-	start_time: string // HH:mm，与 end_time 均空=全天
-	end_time: string
-	validRange: string[] | undefined // 有效期 [from, to]，可选（促销/定时调价）
-	percent: number // 乘数百分比，50 = 半价（提交时换算为 multiplier）
-}
-
 const timePricingEnabled = ref(false)
 const editorTimeSegments = reactive<TimeSegmentRow[]>([])
-
-const dayPresetOptions = [
-	{ label: '每天', value: 'every' },
-	{ label: '工作日', value: 'weekday' },
-	{ label: '周末', value: 'weekend' },
-	{ label: '自定义', value: 'custom' },
-]
-
-const weekdayOptions = [
-	{ label: '周一', value: 1 },
-	{ label: '周二', value: 2 },
-	{ label: '周三', value: 3 },
-	{ label: '周四', value: 4 },
-	{ label: '周五', value: 5 },
-	{ label: '周六', value: 6 },
-	{ label: '周日', value: 7 },
-]
-
-// 预设 → days 数组（提交时换算；every=空数组表示每天）
-const presetToDays: Record<string, number[]> = {
-	every: [],
-	weekday: [1, 2, 3, 4, 5],
-	weekend: [6, 7],
-}
-
-// days 数组 → 预设（回显时换算）
-function daysToPreset(days: number[] | null | undefined): string {
-	if (!days || days.length === 0) return 'every'
-	const sorted = [...days].sort((a, b) => a - b)
-	if (sorted.join(',') === '1,2,3,4,5') return 'weekday'
-	if (sorted.join(',') === '6,7') return 'weekend'
-	return 'custom'
-}
-
-function createEmptySegment(): TimeSegmentRow {
-	return { name: '', dayPreset: 'every', days: [], start_time: '', end_time: '', validRange: undefined, percent: 100 }
-}
-
-function addTimeSegment() {
-	editorTimeSegments.push(createEmptySegment())
-}
-
-function removeTimeSegment(index: number) {
-	editorTimeSegments.splice(index, 1)
-}
-
-// 上移/下移：时段从上到下先命中先生效，促销时段应排在常驻时段之前
-function moveTimeSegment(index: number, offset: number) {
-	const target = index + offset
-	if (target < 0 || target >= editorTimeSegments.length) return
-	const [seg] = editorTimeSegments.splice(index, 1)
-	editorTimeSegments.splice(target, 0, seg)
-}
+const timeSegEditorRef = ref<InstanceType<typeof PricingTimeSegmentsEditor>>()
 
 // 组合预览基础价：随计费模式取当前编辑中的价格（tiered 用首档价）
-const previewBase = computed(() => {
+const previewBase = computed<SegmentPreviewBase>(() => {
 	const first: any = editorItems[0] || {}
 	if (editorBillingMode.value === 'per_second') {
-		return { kind: 'per_second' as const, perSecond: perSecondBasePrice() }
+		return { kind: 'per_second', perSecond: perSecondBasePrice() }
 	}
 	if (editorBillingMode.value === 'per_request') {
-		return { kind: 'per_request' as const, perRequest: Number(first.per_request_price) || 0 }
+		return { kind: 'per_request', perRequest: Number(first.per_request_price) || 0 }
 	}
-	const kind = editorBillingMode.value === 'tiered' ? ('tiered' as const) : ('token' as const)
+	const kind = editorBillingMode.value === 'tiered' ? 'tiered' : 'token'
 	return { kind, input: Number(first.input_price) || 0, output: Number(first.output_price) || 0 }
 })
 
-function segmentPreview(seg: TimeSegmentRow): string {
-	const m = (seg.percent || 0) / 100
-	if (previewBase.value.kind === 'per_second') {
-		return `${formatBilling(previewBase.value.perSecond * m, 4)} /秒`
+// 官方时段组合预览基准价：随官方计费模式取官方编辑中的价格（与 previewBase 同构）
+const officialPreviewBase = computed<SegmentPreviewBase>(() => {
+	const first: any = officialFirst()
+	if (officialBillingMode.value === 'per_second') {
+		return { kind: 'per_second', perSecond: officialPerSecondBasePrice() }
 	}
-	if (previewBase.value.kind === 'per_request') {
-		return `${formatBilling(previewBase.value.perRequest * m, 4)} /次`
+	if (officialBillingMode.value === 'per_request') {
+		return { kind: 'per_request', perRequest: Number(first.per_request_price) || 0 }
 	}
-	const prefix = previewBase.value.kind === 'tiered' ? '首档 ' : ''
-	return `${prefix}输入 ${formatBilling(previewBase.value.input * m, 4)} · 输出 ${formatBilling(previewBase.value.output * m, 4)}`
-}
-
-function defaultPreviewText(): string {
-	if (previewBase.value.kind === 'per_second') {
-		return `${formatBilling(previewBase.value.perSecond, 4)} /秒`
-	}
-	if (previewBase.value.kind === 'per_request') {
-		return `${formatBilling(previewBase.value.perRequest, 4)} /次`
-	}
-	const prefix = previewBase.value.kind === 'tiered' ? '首档 ' : ''
-	return `${prefix}输入 ${formatBilling(previewBase.value.input, 4)} · 输出 ${formatBilling(previewBase.value.output, 4)}`
-}
-
-function segmentDesc(seg: TimeSegmentRow): string {
-	const daysText =
-		seg.dayPreset === 'custom'
-			? seg.days.length
-				? [...seg.days]
-						.sort((a, b) => a - b)
-						.map((d) => '周' + '一二三四五六日'[d - 1])
-						.join('、')
-				: '每天'
-			: dayPresetOptions.find((o) => o.value === seg.dayPreset)?.label || '每天'
-	const timeText = seg.start_time && seg.end_time ? `${seg.start_time}~${seg.end_time}` : '全天'
-	let rangeText = ''
-	if (seg.validRange?.[0]) {
-		rangeText = seg.validRange[1] ? `，${seg.validRange[0]}~${seg.validRange[1]}` : `，${seg.validRange[0]} 起`
-	}
-	return `${daysText} ${timeText}${rangeText}`
-}
-
-// 提交载荷：percent → multiplier，预设 → days
-function segmentsPayload(): any[] {
-	if (!timePricingEnabled.value) return []
-	return editorTimeSegments.map((seg) => ({
-		name: seg.name.trim(),
-		days: seg.dayPreset === 'custom' ? [...seg.days].sort((a, b) => a - b) : presetToDays[seg.dayPreset] || [],
-		start_time: seg.start_time || '',
-		end_time: seg.end_time || '',
-		valid_from: seg.validRange?.[0] || '',
-		valid_to: seg.validRange?.[1] || '',
-		multiplier: (seg.percent || 0) / 100,
-	}))
-}
-
-// 回显：multiplier → percent，days → 预设
-function loadTimeSegments(list: any[] | null | undefined) {
-	editorTimeSegments.length = 0
-	timePricingEnabled.value = Array.isArray(list) && list.length > 0
-	if (!timePricingEnabled.value) return
-	for (const seg of list || []) {
-		editorTimeSegments.push({
-			name: seg.name || '',
-			dayPreset: daysToPreset(seg.days),
-			days: Array.isArray(seg.days) ? [...seg.days] : [],
-			start_time: seg.start_time || '',
-			end_time: seg.end_time || '',
-			validRange:
-				seg.valid_from || seg.valid_to ? [seg.valid_from || '', seg.valid_to || ''] : undefined,
-			percent: Math.round((Number(seg.multiplier) || 1) * 10000) / 100,
-		})
-	}
-}
-
-function resetTimeSegments() {
-	timePricingEnabled.value = false
-	editorTimeSegments.length = 0
-}
+	const kind = officialBillingMode.value === 'tiered' ? 'tiered' : 'token'
+	return { kind, input: Number(first.input_price) || 0, output: Number(first.output_price) || 0 }
+})
 
 // ============================================================
 // Tiered Mode Helpers
@@ -673,31 +862,6 @@ function removeTier(index: number) {
 // ============================================================
 async function savePricing() {
 	if (!props.modelId) return
-	// 时段定价前置校验（完整校验由后端 ValidateTimeSegments 兜底）
-	if (timePricingEnabled.value) {
-		if (editorTimeSegments.length === 0) {
-			Message.warning('已开启时段定价，请至少添加一条时段')
-			return
-		}
-		for (const [i, seg] of editorTimeSegments.entries()) {
-			if (!seg.name.trim()) {
-				Message.warning(`第 ${i + 1} 条时段名称不能为空`)
-				return
-			}
-			if (!seg.percent || seg.percent <= 0) {
-				Message.warning(`时段「${seg.name}」乘数必须大于 0`)
-				return
-			}
-			if ((seg.start_time ? 1 : 0) !== (seg.end_time ? 1 : 0)) {
-				Message.warning(`时段「${seg.name}」开始与结束时间需同时填写或同时留空`)
-				return
-			}
-			if (seg.dayPreset === 'custom' && seg.days.length === 0) {
-				Message.warning(`时段「${seg.name}」自定义适用日至少选择一天`)
-				return
-			}
-		}
-	}
 	editorSaving.value = true
 	try {
 		// 按秒模式：行编辑器 → 矩阵（校验失败中止保存）
@@ -709,12 +873,38 @@ async function savePricing() {
 				return
 			}
 		}
-		// 参数倍率：行编辑器 → 提交载荷（校验失败中止保存）
-		const paramMultipliers = buildParamMultipliersPayload()
-		if (paramMultipliers === null) {
+		// 时段定价：编辑器组件校验并生成载荷（校验失败中止保存）
+		const timeSegments = timeSegEditorRef.value?.buildTimeSegmentsPayload()
+		if (timeSegments === null || timeSegments === undefined) {
 			editorSaving.value = false
 			return
 		}
+		// 参数倍率：编辑器组件校验并生成载荷（校验失败中止保存）
+		const paramMultipliers = paramEditorRef.value?.buildParamMultipliersPayload()
+		if (paramMultipliers === null || paramMultipliers === undefined) {
+			editorSaving.value = false
+			return
+		}
+		// 官方时段/参数倍率：行数组纯函数构建（编辑器未挂载也可用）；校验失败中止保存，与主定价一致
+		const officialSegsPayload = officialTimeSegmentsPayload()
+		if (officialSegsPayload === null) {
+			editorSaving.value = false
+			return
+		}
+		const officialRulesPayload = officialParamRulesPayload()
+		if (officialRulesPayload === null) {
+			editorSaving.value = false
+			return
+		}
+		// 官方按秒矩阵：重复规格/负价校验（官方价为可选参照，空矩阵=未配置交后端清除，不强制正价）
+		if (officialBillingMode.value === 'per_second') {
+			const officialPerSecond = buildPerSecondMap(officialPerSecondRows, false)
+			if (officialPerSecond.map === null) {
+				if (officialPerSecond.error) Message.warning(officialPerSecond.error)
+				editorSaving.value = false
+				return
+			}
+		}
 		const items = editorItems.map((item, index) => ({
 			billing_mode: editorBillingMode.value,
 			min_tokens: editorBillingMode.value === 'tiered' ? item.min_tokens : 0,
@@ -728,8 +918,12 @@ async function savePricing() {
 		}))
 		await request.put(`/admin/models/${props.modelId}/pricing`, {
 			items,
-			time_segments: segmentsPayload(),
+			time_segments: timeSegments,
 			param_multipliers: paramMultipliers,
+			// 官方定价：三数组恒传（后端 OfficialItems nil 才是「不动」），全量替换语义；上方已校验
+			official_items: officialItemsPayload(),
+			official_time_segments: officialSegsPayload,
+			official_param_multipliers: officialRulesPayload,
 			price_note: editorPriceNote.value.trim(),
 			discount_label: editorDiscountLabel.value.trim(),
 			price_change_note: editorPriceChangeNote.value.trim(),
@@ -790,83 +984,32 @@ watch(() => props.visible, (val) => {
 						<ARadioGroup v-model="editorBillingMode" type="button">
 							<ARadio v-for="opt in billingModeOptions" :key="opt.value" :value="opt.value">{{ opt.label }}</ARadio>
 						</ARadioGroup>
-						<APopover
-							trigger="click"
-							position="br"
-							content-class="official-reference-popup"
-							:popup-visible="officialPricingVisible"
-							@popup-visible-change="handleOfficialPricingVisibleChange"
-						>
-							<AButton size="small" type="outline" :loading="officialLoading">
-								<template #icon><IconCloudDownload /></template>
-								官方参考价
-							</AButton>
-							<template #content>
-								<div class="official-reference-panel">
-									<div class="official-reference-header">
-										<div>
-											<div class="official-reference-title">官方参考定价</div>
-											<div class="official-reference-model">{{ officialData?.model_name || modelIdStr }}</div>
-										</div>
-										<AButton size="mini" :loading="officialLoading" @click="fetchOfficialPricing">
-											<template #icon><IconRefresh /></template>
-											重新拉取
-										</AButton>
-									</div>
-
-									<div v-if="officialLoading && !officialData" class="official-reference-state">
-										<ASpin />
-									</div>
-									<AAlert v-else-if="officialError" type="error" :title="officialError" />
-									<template v-else-if="officialData">
-										<div v-if="displayCurrency === 'CNY'" class="official-reference-hint">
-											数据源价格单位为美元，已按 1 USD ≈ ¥{{ (1 / cnyToUsd).toFixed(4) }} 折算为人民币，括号内为美元原值
-										</div>
-										<div class="official-source-grid">
-											<div v-for="src in officialData.sources" :key="src.source" class="official-source-card">
-												<div class="official-source-header">
-													<ATag size="small" :color="getOfficialSourceMeta(src.source).color">
-														{{ getOfficialSourceMeta(src.source).label }}
-													</ATag>
-													<template v-if="src.found && src.pricing">
-														<ATag v-if="src.provider" size="small" color="orangered">{{ src.provider }}</ATag>
-														<ATag v-if="src.mode" size="small">{{ src.mode }}</ATag>
-													</template>
-												</div>
-												<template v-if="src.found && src.pricing">
-													<div v-if="src.max_context_tokens || src.max_output_tokens" class="official-source-meta">
-														<span v-if="src.max_context_tokens">上下文 {{ (src.max_context_tokens / 1000).toFixed(0) }}K</span>
-														<span v-if="src.max_output_tokens">输出 {{ (src.max_output_tokens / 1000).toFixed(0) }}K</span>
-													</div>
-													<div class="official-prices">
-														<div class="official-price-row">
-															<span class="official-price-label">输入价格</span>
-															<span class="official-price-value">{{ formatOfficialPrice(src.pricing.input_price) }} / 1M</span>
-														</div>
-														<div class="official-price-row">
-															<span class="official-price-label">输出价格</span>
-															<span class="official-price-value">{{ formatOfficialPrice(src.pricing.output_price) }} / 1M</span>
-														</div>
-														<div class="official-price-row">
-															<span class="official-price-label">缓存读取</span>
-															<span class="official-price-value">{{ src.pricing.cache_read_price ? formatOfficialPrice(src.pricing.cache_read_price) + ' / 1M' : '—' }}</span>
-														</div>
-														<div class="official-price-row">
-															<span class="official-price-label">缓存创建</span>
-															<span class="official-price-value">{{ src.pricing.cache_creation_price ? formatOfficialPrice(src.pricing.cache_creation_price) + ' / 1M' : '—' }}</span>
-														</div>
-													</div>
-													<AButton type="primary" size="small" long @click="applyOfficialPricing(src.pricing)">应用此价格</AButton>
-												</template>
-												<div v-else class="official-not-found" :class="{ 'official-not-found--error': src.error }">
-													{{ src.error ? '数据源暂时不可用' : '未找到该模型' }}
-												</div>
-											</div>
-										</div>
-									</template>
-								</div>
-							</template>
-						</APopover>
+						<div class="billing-mode-tools">
+							<!-- 官方价状态：颜色区分是否配置；点击标签进二层弹窗设置。已配置时右侧直接给快速折扣录入 -->
+							<div
+								class="official-quick"
+								:title="hasOfficialPricing ? `官方价基准已设置（非计费依据）${officialFoldSummary() ? '，' + officialFoldSummary() : ''}；点击标签可修改` : '官方价基准未设置；点击标签设置后可按折扣一键生成我方定价'"
+							>
+								<ATag :color="hasOfficialPricing ? 'green' : 'gray'" class="official-quick-tag" @click="openOfficialModal">
+									{{ hasOfficialPricing ? '官方价已设置' : '官方价未设置' }}
+								</ATag>
+								<template v-if="hasOfficialPricing">
+									<AInputNumber
+										v-model="officialDiscountPercent"
+										:min="1"
+										:max="1000"
+										:step="5"
+										:precision="1"
+										size="small"
+										class="official-quick-input"
+										title="官方价 × 折扣 → 填入我方定价"
+									>
+										<template #suffix>%</template>
+									</AInputNumber>
+									<AButton size="small" type="primary" @click="applyOfficialToPricing">按官方价填入</AButton>
+								</template>
+							</div>
+						</div>
 					</div>
 				</div>
 
@@ -881,7 +1024,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="editorItems[0].per_request_price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="每次调用价格"
 									class="w-full"
 								>
@@ -915,7 +1058,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="row.price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="0"
 									class="per-second-price"
 								>
@@ -956,7 +1099,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="editorItems[0].input_price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="0"
 									class="w-full"
 								>
@@ -967,7 +1110,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="editorItems[0].output_price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="0"
 									class="w-full"
 								>
@@ -978,7 +1121,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="editorItems[0].cache_read_price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="0"
 									class="w-full"
 								>
@@ -989,7 +1132,7 @@ watch(() => props.visible, (val) => {
 								<AInputNumber
 									v-model="editorItems[0].cache_creation_price"
 									:min="0"
-									:precision="4"
+									:precision="6"
 									placeholder="0"
 									class="w-full"
 								>
@@ -1042,7 +1185,7 @@ watch(() => props.visible, (val) => {
 									<AInputNumber
 										v-model="tier.input_price"
 										:min="0"
-										:precision="4"
+										:precision="6"
 										class="w-full"
 									>
 										<template #suffix>{{ currencySymbol }}/1M</template>
@@ -1052,7 +1195,7 @@ watch(() => props.visible, (val) => {
 									<AInputNumber
 										v-model="tier.output_price"
 										:min="0"
-										:precision="4"
+										:precision="6"
 										class="w-full"
 									>
 										<template #suffix>{{ currencySymbol }}/1M</template>
@@ -1064,7 +1207,7 @@ watch(() => props.visible, (val) => {
 									<AInputNumber
 										v-model="tier.cache_read_price"
 										:min="0"
-										:precision="4"
+										:precision="6"
 										class="w-full"
 									>
 										<template #suffix>{{ currencySymbol }}/1M</template>
@@ -1074,7 +1217,7 @@ watch(() => props.visible, (val) => {
 									<AInputNumber
 										v-model="tier.cache_creation_price"
 										:min="0"
-										:precision="4"
+										:precision="6"
 										class="w-full"
 									>
 										<template #suffix>{{ currencySymbol }}/1M</template>
@@ -1086,197 +1229,16 @@ watch(() => props.visible, (val) => {
 					</div>
 				</template>
 
-				<!-- Time Segment Pricing（时段定价：峰谷/工作时段/促销） -->
-				<div class="editor-section">
-					<div class="editor-section-header">
-						<h3>时段定价</h3>
-						<ASwitch v-model="timePricingEnabled" size="small" />
-						<span class="section-hint">全部价格（含各档位/缓存/按次价）按乘数等比缩放：100% = 默认价，未命中时段按默认价</span>
-					</div>
-					<template v-if="timePricingEnabled">
-						<div v-for="(seg, index) in editorTimeSegments" :key="index" class="tier-card">
-							<div class="tier-header">
-								<div class="segment-tools">
-									<AButton size="mini" :disabled="index === 0" @click="moveTimeSegment(index, -1)">↑</AButton>
-									<AButton size="mini" :disabled="index === editorTimeSegments.length - 1" @click="moveTimeSegment(index, 1)">↓</AButton>
-									<span class="tier-label">第 {{ index + 1 }} 条</span>
-								</div>
-								<AButton size="mini" status="danger" @click="removeTimeSegment(index)">删除</AButton>
-							</div>
-							<div class="grid grid-cols-2 md:grid-cols-4 gap-x-4">
-								<AFormItem label="时段名称">
-									<AInput v-model="seg.name" placeholder="如：闲时 / 工作忙时" :maxlength="32" allow-clear />
-								</AFormItem>
-								<AFormItem label="价格乘数">
-									<AInputNumber v-model="seg.percent" :min="1" :max="1000" :step="5" :precision="0" class="w-full">
-										<template #suffix>%</template>
-									</AInputNumber>
-								</AFormItem>
-								<AFormItem label="每日时段（留空 = 全天）" class="md:col-span-2">
-									<div class="time-range">
-										<ATimePicker v-model="seg.start_time" format="HH:mm" allow-clear placeholder="开始" class="w-full" />
-										<span class="time-sep">~</span>
-										<ATimePicker v-model="seg.end_time" format="HH:mm" allow-clear placeholder="结束" class="w-full" />
-									</div>
-								</AFormItem>
-							</div>
-							<div class="grid grid-cols-1 md:grid-cols-2 gap-x-4 mt-1">
-								<AFormItem label="适用日">
-									<ARadioGroup v-model="seg.dayPreset" type="button" size="small">
-										<ARadio v-for="opt in dayPresetOptions" :key="opt.value" :value="opt.value">{{ opt.label }}</ARadio>
-									</ARadioGroup>
-								</AFormItem>
-								<AFormItem label="有效期（促销/定时调价，可选）">
-									<ARangePicker v-model="seg.validRange" class="w-full" allow-clear />
-								</AFormItem>
-								<AFormItem
-									v-if="seg.dayPreset === 'custom'"
-									label="自定义星期"
-									class="custom-days-item md:col-span-2"
-								>
-									<div class="custom-days">
-										<ACheckboxGroup v-model="seg.days" :options="weekdayOptions" />
-									</div>
-								</AFormItem>
-							</div>
-							<div class="segment-preview">{{ segmentDesc(seg) }} → {{ segmentPreview(seg) }}</div>
-						</div>
-						<AButton type="dashed" long class="mt-3" @click="addTimeSegment">+ 添加时段</AButton>
-						<div class="combo-preview-hint">时段从上到下先命中先生效：限时促销时段应排在常驻时段上方</div>
+				<!-- Time Segment Pricing（时段定价：峰谷/工作时段/促销）——编辑器组件与官方弹窗共用 -->
+				<PricingTimeSegmentsEditor
+					ref="timeSegEditorRef"
+					v-model:enabled="timePricingEnabled"
+					:segments="editorTimeSegments"
+					:preview-base="previewBase"
+				/>
 
-						<!-- 组合预览：换算后的实际价格 -->
-						<div v-if="editorTimeSegments.length" class="combo-preview">
-							<div class="combo-preview-title">价格预览（换算后实际价格）</div>
-							<div class="combo-row">
-								<span class="combo-name">默认价（未命中时段）</span>
-								<span class="combo-value">{{ defaultPreviewText() }}</span>
-							</div>
-							<div v-for="(seg, index) in editorTimeSegments" :key="index" class="combo-row">
-								<span class="combo-name">{{ seg.name || `时段 ${index + 1}` }}（{{ segmentDesc(seg) }}）</span>
-								<span class="combo-value">{{ segmentPreview(seg) }}</span>
-							</div>
-						</div>
-					</template>
-				</div>
-
-				<!-- Param Multipliers（参数倍率：按请求参数匹配加/折扣，所有计费模式共享） -->
-				<div class="editor-section">
-					<div class="editor-section-header">
-						<h3>参数倍率</h3>
-						<span class="section-hint">按归一化任务体参数匹配（如含参考图 / 时长档位 / 视频输入），命中规则连乘；所有计费模式共享</span>
-					</div>
-					<div v-for="(rule, ruleIndex) in paramRules" :key="ruleIndex" class="tier-card">
-						<!-- 头行：命中说明（默认占位"规则N"）跨前两列 · 命中倍率对齐「值」列 · 删除列 -->
-						<div class="param-rule-head">
-							<div class="param-field param-field--note">
-								<span class="field-label field-label--required">说明</span>
-								<AInput
-									v-model="rule.note"
-									:placeholder="`规则 ${ruleIndex + 1}`"
-									:max-length="64"
-									allow-clear
-									class="param-note-input"
-								/>
-							</div>
-							<div class="param-field param-field--mult">
-								<span class="field-label field-label--required">倍率</span>
-								<AInputNumber
-									v-model="rule.multiplier"
-									:min="0.0001"
-									:max="100"
-									:precision="4"
-									title="命中倍率"
-									class="param-multiplier-input"
-								>
-									<template #suffix>×</template>
-								</AInputNumber>
-							</div>
-							<!-- 删除整条规则：垃圾桶图标，与下方条件行的「−」同宽同列 -->
-							<AButton
-								class="param-head-remove"
-								size="mini"
-								status="danger"
-								title="删除该规则"
-								@click="removeParamRule(ruleIndex)"
-							>
-								<IconDelete />
-							</AButton>
-						</div>
-						<!-- 条件行：路径 / 匹配 / 值 / 删除 四列固定网格；「值」列恒占位（无需比对值时留空），
-						     各条件行纵向对齐，不随匹配方式增减列而跳动 -->
-						<div
-							v-for="(cond, condIndex) in rule.conditions"
-							:key="condIndex"
-							class="param-condition-grid"
-						>
-							<div class="param-field param-field--path">
-								<span class="field-label field-label--required">路径</span>
-								<ASelect
-									v-model="cond.path"
-									:options="paramPathPresets.map((p) => ({ label: p, value: p }))"
-									allow-create
-									allow-search
-									placeholder="如 metadata.image"
-									class="param-path-select"
-								/>
-							</div>
-							<div class="param-field param-field--match">
-								<span class="field-label field-label--required">匹配</span>
-								<ASelect v-model="cond.match" :options="paramMatchOptions" class="param-match-select" />
-							</div>
-							<div
-								class="param-field param-field--value"
-								:class="{ 'is-empty': !conditionNeedsValue(cond.match) }"
-							>
-								<span class="field-label field-label--required">值</span>
-								<AInput
-									v-model="cond.value"
-									:placeholder="cond.match === 'between' ? 'min,max（如 8,12）' : '比对值'"
-									class="param-value-input"
-								/>
-							</div>
-							<!-- 行尾「−」= 移除该条件（仅剩一条时禁用）；不用 ✕ 避免被当成关闭弹窗 -->
-							<AButton
-								class="param-cond-remove"
-								size="mini"
-								status="danger"
-								title="移除该条件"
-								:disabled="rule.conditions.length <= 1"
-								@click="removeParamCondition(ruleIndex, condIndex)"
-							>−</AButton>
-						</div>
-						<AButton size="mini" type="text" @click="addParamCondition(ruleIndex)">+ 添加条件（全部满足才命中）</AButton>
-					</div>
-					<AButton type="dashed" long class="mt-3" @click="addParamRule">+ 添加规则</AButton>
-
-					<!-- 试匹配：粘贴任务体 JSON 即时验证规则命中 -->
-					<div v-if="paramRules.length" class="param-try-match">
-						<div class="combo-preview-title">试匹配（粘贴归一化任务体 JSON 验证命中）</div>
-						<ATextarea
-							v-model="tryMatchInput"
-							:auto-size="{ minRows: 3, maxRows: 8 }"
-							placeholder='如 {"model":"...","prompt":"...","seconds":"8","metadata":{"image":"https://...","duration":8}}'
-						/>
-						<template v-if="tryMatchResult()">
-							<div class="combo-row">
-								<span class="combo-name">命中规则</span>
-								<span class="combo-value">
-									<template v-if="tryMatchResult()!.hits.length">
-										<ATag v-for="(h, i) in tryMatchResult()!.hits" :key="i" size="small" color="arcoblue">
-											{{ h.label }} ×{{ h.multiplier }}
-										</ATag>
-									</template>
-									<template v-else>无（按原价）</template>
-								</span>
-							</div>
-							<div class="combo-row">
-								<span class="combo-name">总倍率</span>
-								<span class="combo-value">×{{ tryMatchResult()!.total }}</span>
-							</div>
-						</template>
-						<div v-else-if="tryMatchInput.trim()" class="combo-preview-hint">JSON 解析失败或为空</div>
-					</div>
-				</div>
+				<!-- Param Multipliers（参数倍率：按请求参数匹配加/折扣）——编辑器组件与官方弹窗共用 -->
+				<PricingParamRulesEditor ref="paramEditorRef" :rules="paramRules" />
 
 				<!-- 展示信息（折扣标签 / 价格调整说明对外展示，价格说明仅内部可见） -->
 				<div class="editor-section">
@@ -1306,6 +1268,295 @@ watch(() => props.visible, (val) => {
 		</AForm>
 		</ASpin>
 	</AModal>
+
+	<!-- 官方定价基准：二层弹窗（数据源参考价 → 官方价编辑 → 折扣换算填入），与我方定价解耦。
+	     误关无损失：官方价改动留在组件 reactive 里，随主弹窗「保存定价」落库才生效 -->
+	<AModal
+		:visible="officialModalVisible"
+		:title="`官方定价基准 - ${modelIdStr}`"
+		:width="'min(880px, 96vw)'"
+		:body-style="{ maxHeight: '72vh', overflowY: 'auto' }"
+		@cancel="officialModalVisible = false"
+		@close="officialModalVisible = false"
+	>
+		<!-- 官方定价（基准，可人工核对修正；结构与主定价同构，支持全部四种计费模式）。
+		     数据源参考价为浮窗（APopover 挂在标题行按钮上），不混入页面内容 -->
+		<div class="official-modal-section">
+			<div class="official-modal-section-head">
+				<h4>官方定价（基准）</h4>
+				<span class="official-modal-section-hint">单位随本位币（{{ currencySymbol }}）</span>
+				<APopover
+					trigger="click"
+					position="bottom"
+					:content-style="{ padding: '12px', width: 'min(680px, 90vw)' }"
+					@popup-visible-change="onSourcesVisibleChange"
+				>
+					<AButton size="mini" class="official-sources-trigger">
+						<template #icon><IconCloudDownload /></template>
+						数据源参考价
+					</AButton>
+					<template #content>
+						<div class="official-sources-panel">
+							<div class="official-sources-panel-head">
+								<span class="official-sources-panel-title">数据源参考价</span>
+								<AButton size="mini" :loading="officialLoading" @click="fetchOfficialPricing">
+									<template #icon><IconRefresh /></template>
+									重新拉取
+								</AButton>
+							</div>
+							<div v-if="officialLoading && !officialData" class="official-reference-state">
+								<ASpin />
+								<span class="official-loading-text">正在拉取 4 个数据源…</span>
+							</div>
+							<AAlert v-else-if="officialError" type="error" :title="officialError" />
+							<div v-else-if="officialData" class="official-source-grid">
+								<div v-for="src in officialData.sources" :key="src.source" class="official-source-card">
+									<div class="official-source-header">
+										<ATag size="small" :color="getOfficialSourceMeta(src.source).color">
+											{{ getOfficialSourceMeta(src.source).label }}
+										</ATag>
+										<template v-if="src.found && src.pricing">
+											<ATag v-if="src.provider" size="small" color="orangered">{{ src.provider }}</ATag>
+											<ATag v-if="src.mode" size="small">{{ src.mode }}</ATag>
+											<ATag v-if="isCurrentBaseline(src)" size="small" color="green">已是当前基准</ATag>
+										</template>
+									</div>
+									<template v-if="src.found && src.pricing">
+										<div v-if="src.max_context_tokens || src.max_output_tokens" class="official-source-meta">
+											<span v-if="src.max_context_tokens">上下文 {{ (src.max_context_tokens / 1000).toFixed(0) }}K</span>
+											<span v-if="src.max_output_tokens">输出 {{ (src.max_output_tokens / 1000).toFixed(0) }}K</span>
+										</div>
+										<div class="official-prices">
+											<div class="official-price-row">
+												<span class="official-price-label">输入价格</span>
+												<span class="official-price-value">{{ formatOfficialPrice(src.pricing.input_price) }} / 1M</span>
+											</div>
+											<div class="official-price-row">
+												<span class="official-price-label">输出价格</span>
+												<span class="official-price-value">{{ formatOfficialPrice(src.pricing.output_price) }} / 1M</span>
+											</div>
+											<div class="official-price-row">
+												<span class="official-price-label">缓存读取</span>
+												<span class="official-price-value">{{ src.pricing.cache_read_price ? formatOfficialPrice(src.pricing.cache_read_price) + ' / 1M' : '—' }}</span>
+											</div>
+											<div class="official-price-row">
+												<span class="official-price-label">缓存创建</span>
+												<span class="official-price-value">{{ src.pricing.cache_creation_price ? formatOfficialPrice(src.pricing.cache_creation_price) + ' / 1M' : '—' }}</span>
+											</div>
+										</div>
+										<AButton
+											type="primary"
+											size="small"
+											long
+											:disabled="officialBillingMode === 'per_second'"
+											:title="officialBillingMode === 'per_second' ? '官方定价当前为按秒模式，数据源无按秒价格' : ''"
+											@click="applySourceToOfficial(src.pricing)"
+										>采用为官方价</AButton>
+									</template>
+									<div v-else class="official-not-found" :class="{ 'official-not-found--error': src.error }">
+										{{ src.error ? '数据源暂时不可用' : '未找到该模型' }}
+									</div>
+								</div>
+							</div>
+						</div>
+					</template>
+				</APopover>
+			</div>
+			<div class="official-mode-row">
+				<ARadioGroup v-model="officialBillingMode" type="button" size="small">
+					<ARadio v-for="opt in officialBillingModeOptions" :key="opt.value" :value="opt.value">{{ opt.label }}</ARadio>
+				</ARadioGroup>
+			</div>
+
+			<!-- 四种模式分支：officialItems 保证至少一行（首行由 ensureOfficialFirstRow 兜底），
+			     v-if 再防御一次空数组渲染 -->
+			<template v-if="officialItems.length > 0">
+			<!-- 官方按次定价 -->
+			<template v-if="officialBillingMode === 'per_request'">
+				<div class="grid grid-cols-2 gap-x-4">
+					<AFormItem label="官方按次单价">
+						<AInputNumber
+							v-model="officialItems[0].per_request_price"
+							:min="0"
+							:precision="6"
+							placeholder="官方每次调用价格"
+							class="w-full"
+						>
+							<template #suffix>{{ currencySymbol }} / 次</template>
+						</AInputNumber>
+					</AFormItem>
+				</div>
+			</template>
+
+			<!-- 官方按秒定价（数据源无按秒价，按官方公布价格手动填写） -->
+			<template v-else-if="officialBillingMode === 'per_second'">
+				<div class="per-second-card">
+					<div v-if="officialPerSecondRows.length" class="per-second-col-head">
+						<span>规格</span>
+						<span>每秒单价</span>
+						<span class="per-second-op-col"></span>
+					</div>
+					<div v-for="(row, index) in officialPerSecondRows" :key="index" class="per-second-row">
+						<AInput
+							v-model="row.spec"
+							placeholder="如 720p / 1080p / *（兜底）"
+							:max-length="32"
+							class="per-second-spec"
+						/>
+						<AInputNumber
+							v-model="row.price"
+							:min="0"
+							:precision="6"
+							placeholder="0"
+							class="per-second-price"
+						>
+							<template #suffix>{{ currencySymbol }} / 秒</template>
+						</AInputNumber>
+						<AButton
+							size="mini"
+							status="danger"
+							title="删除该规格"
+							@click="removeOfficialPerSecondRow(index)"
+						>−</AButton>
+					</div>
+					<div v-if="!officialPerSecondRows.length" class="per-second-empty">
+						数据源无按秒价格，请按官方公布价格手动填写
+					</div>
+				</div>
+				<div class="flex items-center gap-2 mt-2">
+					<AButton size="small" type="outline" @click="addOfficialPerSecondRow()">+ 添加规格</AButton>
+					<AButton
+						v-for="preset in perSecondSpecPresets"
+						:key="preset"
+						size="mini"
+						@click="addOfficialPerSecondRow(preset)"
+					>{{ preset }}</AButton>
+				</div>
+			</template>
+
+			<!-- 官方阶梯定价（与我方阶梯同构：逐档 min/max/输入/输出/缓存价） -->
+			<template v-else-if="officialBillingMode === 'tiered'">
+				<div v-for="(tier, index) in officialItems" :key="index" class="tier-card">
+					<div class="tier-header">
+						<span class="tier-label">第 {{ index + 1 }} 档</span>
+						<AButton
+							size="mini"
+							status="danger"
+							:disabled="officialItems.length <= 1"
+							@click="removeOfficialTier(index)"
+						>删除</AButton>
+					</div>
+					<div class="grid grid-cols-2 md:grid-cols-4 gap-x-4">
+						<AFormItem label="起始 Token">
+							<AInputNumber v-model="tier.min_tokens" :min="0" :precision="0" class="w-full" />
+						</AFormItem>
+						<AFormItem :label="index === officialItems.length - 1 ? '结束（无上限）' : '结束 Token'">
+							<AInputNumber v-if="index < officialItems.length - 1" v-model="tier.max_tokens" :min="0" :precision="0" class="w-full" />
+							<AInput v-else value="∞" disabled />
+						</AFormItem>
+						<AFormItem label="输入价格">
+							<AInputNumber v-model="tier.input_price" :min="0" :precision="6" placeholder="0" class="w-full">
+								<template #suffix>{{ currencySymbol }} / 1M</template>
+							</AInputNumber>
+						</AFormItem>
+						<AFormItem label="输出价格">
+							<AInputNumber v-model="tier.output_price" :min="0" :precision="6" placeholder="0" class="w-full">
+								<template #suffix>{{ currencySymbol }} / 1M</template>
+							</AInputNumber>
+						</AFormItem>
+					</div>
+					<div class="grid grid-cols-2 gap-x-4 mt-1">
+						<AFormItem label="缓存读取价格">
+							<AInputNumber v-model="tier.cache_read_price" :min="0" :precision="6" class="w-full">
+								<template #suffix>{{ currencySymbol }}/1M</template>
+							</AInputNumber>
+						</AFormItem>
+						<AFormItem label="缓存创建价格">
+							<AInputNumber v-model="tier.cache_creation_price" :min="0" :precision="6" class="w-full">
+								<template #suffix>{{ currencySymbol }}/1M</template>
+							</AInputNumber>
+						</AFormItem>
+					</div>
+				</div>
+				<AButton type="dashed" long class="mt-1" @click="addOfficialTier">+ 添加档位</AButton>
+			</template>
+
+			<!-- 官方按量定价 -->
+			<template v-else>
+				<div class="grid grid-cols-2 md:grid-cols-4 gap-x-4">
+					<AFormItem label="输入价格">
+						<AInputNumber
+							v-model="officialItems[0].input_price"
+							:min="0"
+							:precision="6"
+							placeholder="0"
+							class="w-full"
+						>
+							<template #suffix>{{ currencySymbol }} / 1M</template>
+						</AInputNumber>
+					</AFormItem>
+					<AFormItem label="输出价格">
+						<AInputNumber
+							v-model="officialItems[0].output_price"
+							:min="0"
+							:precision="6"
+							placeholder="0"
+							class="w-full"
+						>
+							<template #suffix>{{ currencySymbol }} / 1M</template>
+						</AInputNumber>
+					</AFormItem>
+					<AFormItem label="缓存读取">
+						<AInputNumber
+							v-model="officialItems[0].cache_read_price"
+							:min="0"
+							:precision="6"
+							placeholder="0"
+							class="w-full"
+						>
+							<template #suffix>{{ currencySymbol }} / 1M</template>
+						</AInputNumber>
+					</AFormItem>
+					<AFormItem label="缓存创建">
+						<AInputNumber
+							v-model="officialItems[0].cache_creation_price"
+							:min="0"
+							:precision="6"
+							placeholder="0"
+							class="w-full"
+						>
+							<template #suffix>{{ currencySymbol }} / 1M</template>
+						</AInputNumber>
+					</AFormItem>
+				</div>
+			</template>
+			</template>
+
+			<!-- 官方的时段定价与参数倍率（与主定价一致：始终展示，不做折叠开关） -->
+			<PricingTimeSegmentsEditor
+				v-model:enabled="officialTimeEnabled"
+				:segments="officialTimeSegments"
+				:preview-base="officialPreviewBase"
+				title="时段定价（基准）"
+				hint="随折扣填入时原样复制到主定价（乘数不缩放）"
+			/>
+			<PricingParamRulesEditor
+				:rules="officialParamRules"
+				title="参数倍率（基准）"
+				hint="随折扣填入时原样复制到主定价（乘数不缩放）"
+			/>
+		</div>
+
+		<template #footer>
+			<!-- 底部提示占用现有 footer 插槽：左下角说明文字 + 右侧完成按钮 -->
+			<div class="official-modal-footer">
+				<span class="official-modal-footer-hint">
+					官方价不是计费依据，仅作折扣换算基准与「现价几折」展示；人工核对修正后随主弹窗「保存定价」一并落库。
+				</span>
+				<AButton type="primary" @click="officialModalVisible = false">完成</AButton>
+			</div>
+		</template>
+	</AModal>
 </template>
 
 <style scoped>
@@ -1360,63 +1611,6 @@ watch(() => props.visible, (val) => {
 	color: var(--ta-text-secondary);
 }
 
-.segment-tools {
-	display: flex;
-	align-items: center;
-	gap: 4px;
-}
-
-.time-range {
-	display: flex;
-	align-items: center;
-	gap: 8px;
-	width: 100%;
-}
-
-.time-sep {
-	color: var(--ta-text-tertiary);
-}
-
-.custom-days-item {
-	margin-top: -2px;
-}
-
-.custom-days {
-	box-sizing: border-box;
-	width: 100%;
-	padding: 10px 12px;
-	background: var(--color-fill-2);
-	border-radius: 6px;
-}
-
-.custom-days :deep(.arco-checkbox-group) {
-	display: grid;
-	grid-template-columns: repeat(7, minmax(0, 1fr));
-	gap: 8px 12px;
-	width: 100%;
-}
-
-@media (max-width: 767px) {
-	.custom-days :deep(.arco-checkbox-group) {
-		grid-template-columns: repeat(4, minmax(0, 1fr));
-	}
-}
-
-.segment-preview {
-	margin-top: 10px;
-	padding: 6px 10px;
-	background: var(--color-fill-2);
-	border-radius: 6px;
-	font-size: 12px;
-	color: var(--ta-text-secondary);
-}
-
-.combo-preview-hint {
-	margin-top: 8px;
-	font-size: 12px;
-	color: var(--ta-text-tertiary);
-}
-
 /* 按秒定价：单卡片行式紧凑布局（规格 + 单价 + 删除一行排布） */
 .per-second-card {
 	padding: 10px 12px;
@@ -1465,223 +1659,120 @@ watch(() => props.visible, (val) => {
 	padding: 6px 0;
 }
 
-/* 行内字段标签：灰色小字前置，紧凑布局下的字段语义说明 */
-.field-label {
-	flex: none;
-	font-size: 12px;
-	color: var(--ta-text-tertiary);
-	white-space: nowrap;
-}
-
-/* 必填标记：星号决定位在标签左侧（不占文本宽度），标签整体多留 8px，
-   各行控件左边缘仍对齐；星号色对齐 Arco 表单必填符号 */
-.field-label--required {
-	position: relative;
-	padding-left: 8px;
-}
-
-.field-label--required::before {
-	content: '*';
-	position: absolute;
-	left: 0;
-	color: rgb(var(--danger-6));
-}
-
-/* 参数倍率：规则头行与条件行共用同一套列轨道（路径 · 匹配 · 值 · 删除）。
-   头行「说明」占「路径」列、「倍率」落在「值」列，中间隔开「匹配」列，
-   两个输入框既与下方条件行纵向对齐，又不会挤在一起 */
-.param-rule-head,
-.param-condition-grid {
-	/* 匹配列 152px = 32px 必填标签 + 8px 间隙 + 112px 下拉框：
-	   下拉框内部固定吃掉 50px（边框 2 + 左右内边距 24 + 箭头区 24），剩 62px 文本区，
-	   刚好容纳最长的「大于等于」四字（14px 字号 × 4 = 56px）不被省略号截断 */
-	--param-cols: minmax(0, 1.2fr) 152px minmax(0, 1fr) auto;
-	display: grid;
-	grid-template-columns: var(--param-cols);
+/* 计费模式行右上角工具组：官方价状态 + 快速折扣录入 + 折扣重算 */
+.billing-mode-tools {
+	display: flex;
 	align-items: center;
-	gap: 8px;
-	margin-bottom: 8px;
+	gap: 16px;
+	flex-wrap: wrap;
 }
 
-.param-rule-head {
-	grid-template-areas: 'note . mult remove';
-}
-
-.param-condition-grid {
-	grid-template-areas: 'path match value remove';
-}
-
-/* 行内字段：标签 + 控件（标签定宽，各行控件左边缘对齐） */
-.param-field {
+/* 官方价状态标签：颜色区分是否配置；可点击进二层弹窗设置 */
+.official-quick {
 	display: flex;
 	align-items: center;
 	gap: 8px;
-	min-width: 0;
+	flex-wrap: wrap;
 }
 
-.param-field .field-label {
-	min-width: 32px; /* 8px 必填星号 + 24px 两字标签，保证控件左边缘对齐 */
+.official-quick-tag {
+	cursor: pointer;
 }
 
-.param-field--note {
-	grid-area: note;
+.official-quick-input {
+	width: 88px;
 }
 
-.param-field--mult {
-	grid-area: mult;
-}
-
-.param-field--path {
-	grid-area: path;
-}
-
-.param-field--match {
-	grid-area: match;
-}
-
-.param-field--value {
-	grid-area: value;
-}
-
-/* 控件撑满所属列 */
-.param-field .param-note-input,
-.param-field .param-multiplier-input,
-.param-field .param-path-select,
-.param-field .param-match-select,
-.param-field .param-value-input {
-	flex: 1;
-	min-width: 0;
-}
-
-/* 匹配方式无需比对值（如「有值」）：保留列宽占位，仅隐藏内容 */
-.param-field--value.is-empty {
-	visibility: hidden;
-}
-
-/* 头行删除与条件行移除都是图标按钮：定宽 + 去内边距，两者同宽、右边缘对齐 */
-.param-head-remove,
-.param-cond-remove {
-	grid-area: remove;
-	width: 32px;
-	padding: 0;
-}
-
-/* 窄屏：头行说明独占首行、倍率下移；条件行路径独占首行，匹配 / 值下移，避免列被压扁 */
-@media (max-width: 640px) {
-	.param-rule-head,
-	.param-condition-grid {
-		--param-cols: 152px minmax(0, 1fr) auto;
-		row-gap: 6px;
-	}
-
-	.param-rule-head {
-		grid-template-areas:
-			'note note remove'
-			'mult mult mult';
-	}
-
-	.param-condition-grid {
-		grid-template-areas:
-			'path path remove'
-			'match value value';
-	}
-}
-
-.param-try-match {
-	margin-top: 12px;
-	padding: 10px 14px;
-	background: var(--color-fill-1);
-	border: 1px solid var(--ta-border-light);
-	border-radius: 8px;
-}
-
-.combo-preview {
-	margin-top: 10px;
-	padding: 10px 14px;
-	background: var(--color-fill-1);
-	border: 1px solid var(--ta-border-light);
-	border-radius: 8px;
-}
-
-.combo-preview-title {
-	font-size: 12px;
-	font-weight: 600;
-	color: var(--ta-text-secondary);
-	margin-bottom: 6px;
-}
-
-.combo-row {
+/* 官方价二层弹窗 footer：左下角提示说明 + 右侧完成按钮（复用 footer 插槽，非新增插槽） */
+.official-modal-footer {
 	display: flex;
-	align-items: baseline;
+	align-items: center;
 	justify-content: space-between;
 	gap: 12px;
-	padding: 3px 0;
+}
+
+.official-modal-footer-hint {
+	min-width: 0;
 	font-size: 12px;
+	color: var(--ta-text-tertiary);
+	text-align: left;
 }
 
-.combo-name {
-	color: var(--ta-text-secondary);
-	flex-shrink: 0;
+@media (max-width: 639px) {
+	.official-modal-footer {
+		flex-direction: column-reverse;
+		align-items: stretch;
+	}
+
+	.official-modal-footer-hint {
+		text-align: center;
+	}
 }
 
-.combo-value {
-	color: var(--ta-text-primary);
-	font-family: monospace;
-	text-align: right;
+.official-modal-section {
+	margin-bottom: 20px;
 }
 
-.official-reference-panel {
-	width: min(680px, calc(100vw - 48px));
-	max-height: min(560px, calc(100vh - 96px));
-	overflow-y: auto;
-	padding: 4px;
-	background: var(--color-bg-3);
-	color: var(--color-text-1);
-	border-radius: 6px;
-}
-
-:global(.official-reference-popup) {
-	padding: 10px !important;
-	background: var(--color-bg-3) !important;
-	border-color: var(--color-border) !important;
-	box-shadow: 0 14px 36px rgba(15, 23, 42, 0.2) !important;
-}
-
-.official-reference-header {
+.official-modal-section-head {
 	display: flex;
-	align-items: flex-start;
-	justify-content: space-between;
-	gap: 16px;
-	margin-bottom: 12px;
+	align-items: center;
+	gap: 10px;
+	margin-bottom: 10px;
 }
 
-.official-reference-title {
-	font-size: 14px;
+.official-modal-section-head h4 {
+	margin: 0;
+	font-size: 13px;
 	font-weight: 600;
 	color: var(--ta-text-primary);
 }
 
-.official-reference-model {
-	margin-top: 2px;
+.official-modal-section-hint {
 	font-size: 12px;
 	color: var(--ta-text-tertiary);
-	word-break: break-all;
+}
+
+/* 官方价数据源参考价：浮窗触发按钮推到标题行右侧 */
+.official-sources-trigger {
+	margin-left: auto;
+}
+
+/* 数据源参考价浮窗面板（宽度经 APopover content-style 设定，内容随触发元素渲染） */
+.official-sources-panel {
+	max-height: 56vh;
+	overflow-y: auto;
+}
+
+.official-sources-panel-head {
+	display: flex;
+	align-items: center;
+	justify-content: space-between;
+	gap: 8px;
+	margin-bottom: 10px;
+}
+
+.official-sources-panel-title {
+	font-size: 13px;
+	font-weight: 600;
+	color: var(--ta-text-primary);
 }
 
 .official-reference-state {
 	display: flex;
 	align-items: center;
 	justify-content: center;
-	min-height: 180px;
+	gap: 12px;
+	min-height: 120px;
 }
 
-.official-reference-hint {
-	margin-bottom: 10px;
-	padding: 6px 10px;
+.official-loading-text {
 	font-size: 12px;
-	color: var(--ta-text-secondary);
-	background: var(--color-fill-2);
-	border-radius: 4px;
+	color: var(--ta-text-tertiary);
+}
+
+/* 官方价二层弹窗：模式切换行 */
+.official-mode-row {
+	margin-bottom: 12px;
 }
 
 .official-source-grid {
@@ -1759,10 +1850,6 @@ watch(() => props.visible, (val) => {
 }
 
 @media (max-width: 639px) {
-	.official-reference-panel {
-		width: calc(100vw - 40px);
-	}
-
 	.official-source-grid {
 		grid-template-columns: 1fr;
 	}
diff --git a/web/admin/src/components/PricingParamRulesEditor.vue b/web/admin/src/components/PricingParamRulesEditor.vue
new file mode 100644
index 0000000..5ccbc4e
--- /dev/null
+++ b/web/admin/src/components/PricingParamRulesEditor.vue
@@ -0,0 +1,563 @@
+<script lang="ts">
+// 行数据结构导出（<script setup> 不支持 export，类型声明放前置块）
+export interface ParamConditionRow {
+	path: string
+	match: string // has_value | equals | gt | gte | lt | lte | between
+	value: string // 输入态字符串；between 逗号分隔；提交时按匹配方式转换
+}
+
+export interface ParamRuleRow {
+	conditions: ParamConditionRow[]
+	multiplier: number
+	note: string
+}
+
+// 无需比对值的匹配方式（has_value 只判字段存在）
+function matchNeedsValue(match: string): boolean {
+	return match !== 'has_value'
+}
+
+// 条件输入态 → 提交值（数字类强转、between 转双元素数组、equals 保原样）
+function conditionValuePayloadFrom(cond: ParamConditionRow): any {
+	const raw = cond.value.trim()
+	if (cond.match === 'between') {
+		const parts = raw.split(',').map((s) => s.trim()).filter(Boolean)
+		return parts.length === 2 ? parts.map(Number) : null
+	}
+	if (['gt', 'gte', 'lt', 'lte'].includes(cond.match)) {
+		const n = Number(raw)
+		return raw !== '' && !Number.isNaN(n) ? n : null
+	}
+	return raw // equals：字符串原样（后端数字强转比较）
+}
+
+// API 规则列表 → 行编辑态。父级在编辑器组件未挂载时（如二层弹窗未打开/折叠区未展开）
+// 也用本函数直接填充行数组，与组件内 loadParamMultipliers 共用同一换算
+export function paramRuleRowsFromAPI(list: any[] | null | undefined): ParamRuleRow[] {
+	const rows: ParamRuleRow[] = []
+	if (!Array.isArray(list)) return rows
+	for (const rule of list) {
+		const row: ParamRuleRow = {
+			conditions: (rule.conditions || []).map((c: any) => ({
+				path: c.path || '',
+				match: c.match || 'has_value',
+				value: Array.isArray(c.value) ? c.value.join(',') : c.value != null ? String(c.value) : '',
+			})),
+			multiplier: Number(rule.multiplier) || 1,
+			note: rule.note || '',
+		}
+		if (row.conditions.length > 0) rows.push(row)
+	}
+	return rows
+}
+
+// 行编辑态 → 提交载荷（含校验）。error 非空=校验失败文案（提示方式由调用方决定）
+export function paramRulePayloadFrom(rows: ParamRuleRow[]): { payload?: any[]; error?: string } {
+	const payload: any[] = []
+	for (const [i, rule] of rows.entries()) {
+		if (rule.multiplier <= 0 || rule.multiplier > 100) {
+			return { error: `参数倍率规则 ${i + 1} 倍率需在 (0, 100] 区间` }
+		}
+		if (rule.conditions.length === 0) {
+			return { error: `参数倍率规则 ${i + 1} 至少需要一个条件` }
+		}
+		const conditions: any[] = []
+		for (const [j, cond] of rule.conditions.entries()) {
+			const path = cond.path.trim()
+			if (!path) {
+				return { error: `参数倍率规则 ${i + 1} 条件 ${j + 1} 路径为空` }
+			}
+			const value = conditionValuePayloadFrom(cond)
+			if (matchNeedsValue(cond.match) && (value === null || value === '')) {
+				return { error: `参数倍率规则 ${i + 1} 条件 ${j + 1} 需要填写比对值` }
+			}
+			conditions.push(matchNeedsValue(cond.match) ? { path, match: cond.match, value } : { path, match: cond.match })
+		}
+		// 命中说明：空 = 默认「规则N」（随序号，删除上方规则后自动顺延）
+		payload.push({ conditions, multiplier: rule.multiplier, note: rule.note.trim() || `规则 ${i + 1}` })
+	}
+	return { payload }
+}
+</script>
+
+<script setup lang="ts">
+// 参数倍率编辑器（主弹窗与官方定价弹窗共用）：
+// 按归一化任务体参数匹配，命中规则连乘；规则数组由父级持有（reactive），
+// 编辑/校验/载荷/试匹配逻辑内聚在本组件。
+import { ref } from 'vue'
+import { Message } from '@arco-design/web-vue'
+import { IconDelete } from '@arco-design/web-vue/es/icon'
+
+const props = withDefaults(
+	defineProps<{
+		rules: ParamRuleRow[]
+		title?: string
+		hint?: string
+	}>(),
+	{
+		title: '参数倍率',
+		hint: '按归一化任务体参数匹配（如含参考图 / 时长档位 / 视频输入），命中规则连乘；所有计费模式共享',
+	},
+)
+
+const paramMatchOptions = [
+	{ label: '有值', value: 'has_value' },
+	{ label: '等于', value: 'equals' },
+	{ label: '大于', value: 'gt' },
+	{ label: '大于等于', value: 'gte' },
+	{ label: '小于', value: 'lt' },
+	{ label: '小于等于', value: 'lte' },
+	{ label: '区间', value: 'between' },
+]
+
+// 常用路径预设（归一化任务体，规则跟语义走不跟入口协议走）
+const paramPathPresets = [
+	'metadata.image',
+	'metadata.duration',
+	'metadata.resolution',
+	'metadata.aspect_ratio',
+	'seconds',
+	'metadata.content[*].video_url',
+	'metadata.content[*].role',
+]
+
+function addParamRule() {
+	props.rules.push({ conditions: [{ path: '', match: 'has_value', value: '' }], multiplier: 1, note: '' })
+}
+
+function removeParamRule(index: number) {
+	props.rules.splice(index, 1)
+}
+
+function addParamCondition(ruleIndex: number) {
+	props.rules[ruleIndex].conditions.push({ path: '', match: 'has_value', value: '' })
+}
+
+function removeParamCondition(ruleIndex: number, condIndex: number) {
+	props.rules[ruleIndex].conditions.splice(condIndex, 1)
+}
+
+// 模板绑定：模板只认 setup 绑定，前置块的 matchNeedsValue 经此别名暴露
+const conditionNeedsValue = matchNeedsValue
+
+// 行编辑态 → 提交载荷；校验失败 Message 提示并返回 null（委托前置块纯函数）
+function buildParamMultipliersPayload(): any[] | null {
+	const result = paramRulePayloadFrom(props.rules)
+	if (result.error) {
+		Message.warning(result.error)
+		return null
+	}
+	return result.payload ?? []
+}
+
+// 回显：后端规则 → 行编辑态（委托前置块纯函数，与父级直接填充行数组共用换算）
+function loadParamMultipliers(list: any[] | null | undefined) {
+	const rows = paramRuleRowsFromAPI(list)
+	props.rules.length = 0
+	props.rules.push(...rows)
+}
+
+function resetParamRules() {
+	props.rules.length = 0
+	tryMatchInput.value = ''
+}
+
+// ── 试匹配预览（前端复刻后端求值语义：路径提取 + [*] 扇出 + 数字强转 + 隐式与 + 连乘） ──
+const tryMatchInput = ref('')
+
+function lookupPath(root: any, path: string): { values: any[]; found: boolean } {
+	const segments = path.split('.').filter(Boolean)
+	let current = [root]
+	for (const seg of segments) {
+		const wildcard = seg.endsWith('[*]')
+		const key = wildcard ? seg.slice(0, -3) : seg
+		const next: any[] = []
+		for (const cur of current) {
+			if (cur == null || typeof cur !== 'object' || Array.isArray(cur)) continue
+			const v = (cur as Record<string, any>)[key]
+			if (v === undefined) continue
+			if (wildcard) {
+				if (Array.isArray(v)) next.push(...v)
+			} else {
+				next.push(v)
+			}
+		}
+		if (next.length === 0) return { values: [], found: false }
+		current = next
+	}
+	return { values: current, found: true }
+}
+
+function toNum(v: any): number | null {
+	if (typeof v === 'number') return v
+	if (typeof v === 'string' && v.trim() !== '' && !Number.isNaN(Number(v))) return Number(v)
+	return null
+}
+
+function conditionHit(cond: { path: string; match: string; value?: any }, root: any): boolean {
+	const { values, found } = lookupPath(root, cond.path)
+	if (!found) return false
+	if (cond.match === 'has_value') return values.some((v) => v !== null && v !== undefined)
+	const target = Array.isArray(cond.value) ? cond.value.map(Number) : cond.value
+	if (cond.match === 'equals') {
+		return values.some((v) => {
+			const vn = toNum(v)
+			const tn = toNum(target)
+			if (vn != null && tn != null) return vn === tn
+			return v === target
+		})
+	}
+	if (cond.match === 'between') {
+		if (!Array.isArray(target) || target.length !== 2) return false
+		return values.some((v) => {
+			const n = toNum(v)
+			return n != null && n >= target[0] && n <= target[1]
+		})
+	}
+	const tn = toNum(target)
+	if (tn == null) return false
+	return values.some((v) => {
+		const n = toNum(v)
+		if (n == null) return false
+		if (cond.match === 'gt') return n > tn
+		if (cond.match === 'gte') return n >= tn
+		if (cond.match === 'lt') return n < tn
+		return n <= tn // lte
+	})
+}
+
+// 试匹配结果：命中规则列表 + 总倍率
+function tryMatchResult(): { hits: Array<{ label: string; multiplier: number }>; total: number } | null {
+	const raw = tryMatchInput.value.trim()
+	if (!raw) return null
+	let root: any
+	try {
+		root = JSON.parse(raw)
+	} catch {
+		return null
+	}
+	const hits: Array<{ label: string; multiplier: number }> = []
+	let total = 1
+	for (const rule of props.rules) {
+		const allHit = rule.conditions.every((c) =>
+			conditionHit({ path: c.path, match: c.match, value: conditionValuePayloadFrom(c) }, root),
+		)
+		if (allHit) {
+			total *= rule.multiplier || 1
+			hits.push({ label: rule.note || rule.conditions.map((c) => c.path).join(' & '), multiplier: rule.multiplier })
+		}
+	}
+	return { hits, total }
+}
+
+defineExpose({ loadParamMultipliers, resetParamRules, buildParamMultipliersPayload })
+</script>
+
+<template>
+	<div class="editor-section">
+		<div class="editor-section-header">
+			<h3>{{ title }}</h3>
+			<span class="section-hint">{{ hint }}</span>
+		</div>
+		<div v-for="(rule, ruleIndex) in rules" :key="ruleIndex" class="tier-card">
+			<!-- 头行：命中说明（默认占位"规则N"）跨前两列 · 命中倍率对齐「值」列 · 删除列 -->
+			<div class="param-rule-head">
+				<div class="param-field param-field--note">
+					<span class="field-label field-label--required">说明</span>
+					<AInput
+						v-model="rule.note"
+						:placeholder="`规则 ${ruleIndex + 1}`"
+						:max-length="64"
+						allow-clear
+						class="param-note-input"
+					/>
+				</div>
+				<div class="param-field param-field--mult">
+					<span class="field-label field-label--required">倍率</span>
+					<AInputNumber
+						v-model="rule.multiplier"
+						:min="0.0001"
+						:max="100"
+						:precision="4"
+						title="命中倍率"
+						class="param-multiplier-input"
+					>
+						<template #suffix>×</template>
+					</AInputNumber>
+				</div>
+				<!-- 删除整条规则：垃圾桶图标，与下方条件行的「−」同宽同列 -->
+				<AButton
+					class="param-head-remove"
+					size="mini"
+					status="danger"
+					title="删除该规则"
+					@click="removeParamRule(ruleIndex)"
+				>
+					<IconDelete />
+				</AButton>
+			</div>
+			<!-- 条件行：路径 / 匹配 / 值 / 删除 四列固定网格；「值」列恒占位（无需比对值时留空），
+			     各条件行纵向对齐，不随匹配方式增减列而跳动 -->
+			<div
+				v-for="(cond, condIndex) in rule.conditions"
+				:key="condIndex"
+				class="param-condition-grid"
+			>
+				<div class="param-field param-field--path">
+					<span class="field-label field-label--required">路径</span>
+					<ASelect
+						v-model="cond.path"
+						:options="paramPathPresets.map((p) => ({ label: p, value: p }))"
+						allow-create
+						allow-search
+						placeholder="如 metadata.image"
+						class="param-path-select"
+					/>
+				</div>
+				<div class="param-field param-field--match">
+					<span class="field-label field-label--required">匹配</span>
+					<ASelect v-model="cond.match" :options="paramMatchOptions" class="param-match-select" />
+				</div>
+				<div
+					class="param-field param-field--value"
+					:class="{ 'is-empty': !conditionNeedsValue(cond.match) }"
+				>
+					<span class="field-label field-label--required">值</span>
+					<AInput
+						v-model="cond.value"
+						:placeholder="cond.match === 'between' ? 'min,max（如 8,12）' : '比对值'"
+						class="param-value-input"
+					/>
+				</div>
+				<!-- 行尾「−」= 移除该条件（仅剩一条时禁用）；不用 ✕ 避免被当成关闭弹窗 -->
+				<AButton
+					class="param-cond-remove"
+					size="mini"
+					status="danger"
+					title="移除该条件"
+					:disabled="rule.conditions.length <= 1"
+					@click="removeParamCondition(ruleIndex, condIndex)"
+				>−</AButton>
+			</div>
+			<AButton size="mini" type="text" @click="addParamCondition(ruleIndex)">+ 添加条件（全部满足才命中）</AButton>
+		</div>
+		<AButton type="dashed" long class="mt-3" @click="addParamRule">+ 添加规则</AButton>
+
+		<!-- 试匹配：粘贴任务体 JSON 即时验证规则命中 -->
+		<div v-if="rules.length" class="param-try-match">
+			<div class="combo-preview-title">试匹配（粘贴归一化任务体 JSON 验证命中）</div>
+			<ATextarea
+				v-model="tryMatchInput"
+				:auto-size="{ minRows: 3, maxRows: 8 }"
+				placeholder='如 {"model":"...","prompt":"...","seconds":"8","metadata":{"image":"https://...","duration":8}}'
+			/>
+			<template v-if="tryMatchResult()">
+				<div class="combo-row">
+					<span class="combo-name">命中规则</span>
+					<span class="combo-value">
+						<template v-if="tryMatchResult()!.hits.length">
+							<ATag v-for="(h, i) in tryMatchResult()!.hits" :key="i" size="small" color="arcoblue">
+								{{ h.label }} ×{{ h.multiplier }}
+							</ATag>
+						</template>
+						<template v-else>无（按原价）</template>
+					</span>
+				</div>
+				<div class="combo-row">
+					<span class="combo-name">总倍率</span>
+					<span class="combo-value">×{{ tryMatchResult()!.total }}</span>
+				</div>
+			</template>
+			<div v-else-if="tryMatchInput.trim()" class="combo-preview-hint">JSON 解析失败或为空</div>
+		</div>
+	</div>
+</template>
+
+<style scoped>
+/* 与主弹窗一致的 section / 卡片基础样式（scoped 隔离，组件内自持） */
+.editor-section {
+	margin-bottom: 24px;
+}
+
+.editor-section-header {
+	display: flex;
+	align-items: center;
+	gap: 12px;
+	margin-bottom: 12px;
+}
+
+.editor-section-header h3 {
+	font-size: 14px;
+	font-weight: 600;
+	color: var(--ta-text-primary);
+	margin: 0;
+}
+
+.section-hint {
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+}
+
+.tier-card {
+	padding: 12px 16px;
+	background: var(--color-fill-1);
+	border-radius: 8px;
+	margin-bottom: 8px;
+}
+
+/* 行内字段标签：灰色小字前置，紧凑布局下的字段语义说明 */
+.field-label {
+	flex: none;
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+	white-space: nowrap;
+}
+
+/* 必填标记：星号决定位在标签左侧（不占文本宽度），标签整体多留 8px，
+   各行控件左边缘仍对齐；星号色对齐 Arco 表单必填符号 */
+.field-label--required {
+	position: relative;
+	padding-left: 8px;
+}
+
+.field-label--required::before {
+	content: '*';
+	position: absolute;
+	left: 0;
+	color: rgb(var(--danger-6));
+}
+
+/* 参数倍率：规则头行与条件行共用同一套列轨道（路径 · 匹配 · 值 · 删除）。
+   头行「说明」占「路径」列、「倍率」落在「值」列，中间隔开「匹配」列，
+   两个输入框既与下方条件行纵向对齐，又不会挤在一起 */
+.param-rule-head,
+.param-condition-grid {
+	/* 匹配列 152px = 32px 必填标签 + 8px 间隙 + 112px 下拉框：
+	   下拉框内部固定吃掉 50px（边框 2 + 左右内边距 24 + 箭头区 24），剩 62px 文本区，
+	   刚好容纳最长的「大于等于」四字（14px 字号 × 4 = 56px）不被省略号截断 */
+	--param-cols: minmax(0, 1.2fr) 152px minmax(0, 1fr) auto;
+	display: grid;
+	grid-template-columns: var(--param-cols);
+	align-items: center;
+	gap: 8px;
+	margin-bottom: 8px;
+}
+
+.param-rule-head {
+	grid-template-areas: 'note . mult remove';
+}
+
+.param-condition-grid {
+	grid-template-areas: 'path match value remove';
+}
+
+/* 行内字段：标签 + 控件（标签定宽，各行控件左边缘对齐） */
+.param-field {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+	min-width: 0;
+}
+
+.param-field .field-label {
+	min-width: 32px; /* 8px 必填星号 + 24px 两字标签，保证控件左边缘对齐 */
+}
+
+.param-field--note {
+	grid-area: note;
+}
+
+.param-field--mult {
+	grid-area: mult;
+}
+
+.param-field--path {
+	grid-area: path;
+}
+
+.param-field--match {
+	grid-area: match;
+}
+
+.param-field--value {
+	grid-area: value;
+}
+
+/* 控件撑满所属列 */
+.param-field .param-note-input,
+.param-field .param-multiplier-input,
+.param-field .param-path-select,
+.param-field .param-match-select,
+.param-field .param-value-input {
+	flex: 1;
+	min-width: 0;
+}
+
+/* 匹配方式无需比对值（如「有值」）：保留列宽占位，仅隐藏内容 */
+.param-field--value.is-empty {
+	visibility: hidden;
+}
+
+.param-head-remove,
+.param-cond-remove {
+	grid-area: remove;
+	width: 32px;
+	padding: 0;
+}
+
+/* 窄屏：头行说明独占首行、倍率下移；条件行路径独占首行，匹配 / 值下移，避免列被压扁 */
+@media (max-width: 640px) {
+	.param-rule-head,
+	.param-condition-grid {
+		--param-cols: 152px minmax(0, 1fr) auto;
+		row-gap: 6px;
+	}
+
+	.param-rule-head {
+		grid-template-areas:
+			'note note remove'
+			'mult mult mult';
+	}
+
+	.param-condition-grid {
+		grid-template-areas:
+			'path path remove'
+			'match value value';
+	}
+}
+
+.param-try-match {
+	margin-top: 12px;
+	padding: 10px 14px;
+	background: var(--color-fill-1);
+	border: 1px solid var(--ta-border-light);
+	border-radius: 8px;
+}
+
+.combo-preview-title {
+	font-size: 12px;
+	font-weight: 600;
+	color: var(--ta-text-secondary);
+	margin-bottom: 6px;
+}
+
+.combo-row {
+	display: flex;
+	align-items: baseline;
+	justify-content: space-between;
+	gap: 12px;
+	padding: 3px 0;
+	font-size: 12px;
+}
+
+.combo-value {
+	color: var(--ta-text-primary);
+	font-family: monospace;
+	text-align: right;
+}
+
+.combo-preview-hint {
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+}
+</style>
diff --git a/web/admin/src/components/PricingTimeSegmentsEditor.vue b/web/admin/src/components/PricingTimeSegmentsEditor.vue
new file mode 100644
index 0000000..77f8496
--- /dev/null
+++ b/web/admin/src/components/PricingTimeSegmentsEditor.vue
@@ -0,0 +1,412 @@
+<script lang="ts">
+// 行数据结构导出（<script setup> 不支持 export，类型声明放前置块）
+export interface TimeSegmentRow {
+	name: string
+	dayPreset: string // every / weekday / weekend / custom
+	days: number[] // 仅 custom 使用，1=周一..7=周日
+	start_time: string // HH:mm，与 end_time 均空=全天
+	end_time: string
+	validRange: string[] | undefined // 有效期 [from, to]，可选（促销/定时调价）
+	percent: number // 乘数百分比，50 = 半价（提交时换算为 multiplier）
+}
+
+// 组合预览基准价（父级按当前计费模式计算；不传则预览只显示倍率百分比）
+export interface SegmentPreviewBase {
+	kind: 'token' | 'tiered' | 'per_request' | 'per_second'
+	input?: number
+	output?: number
+	perRequest?: number
+	perSecond?: number
+}
+
+// 预设 → days 数组（提交时换算；every=空数组表示每天）
+const presetToDays: Record<string, number[]> = {
+	every: [],
+	weekday: [1, 2, 3, 4, 5],
+	weekend: [6, 7],
+}
+
+// days 数组 → 预设（回显时换算）
+function daysToPreset(days: number[] | null | undefined): string {
+	if (!days || days.length === 0) return 'every'
+	const sorted = [...days].sort((a, b) => a - b)
+	if (sorted.join(',') === '1,2,3,4,5') return 'weekday'
+	if (sorted.join(',') === '6,7') return 'weekend'
+	return 'custom'
+}
+
+// API 时段列表 → 行编辑态。父级在编辑器组件未挂载时（如二层弹窗未打开/折叠区未展开）
+// 也用本函数直接填充行数组，与组件内 loadTimeSegments 共用同一换算
+export function timeSegmentRowsFromAPI(list: any[] | null | undefined): { rows: TimeSegmentRow[]; enabled: boolean } {
+	const rows: TimeSegmentRow[] = []
+	if (Array.isArray(list)) {
+		for (const seg of list) {
+			rows.push({
+				name: seg.name || '',
+				dayPreset: daysToPreset(seg.days),
+				days: Array.isArray(seg.days) ? [...seg.days] : [],
+				start_time: seg.start_time || '',
+				end_time: seg.end_time || '',
+				validRange: seg.valid_from || seg.valid_to ? [seg.valid_from || '', seg.valid_to || ''] : undefined,
+				percent: Math.round((Number(seg.multiplier) || 1) * 10000) / 100,
+			})
+		}
+	}
+	return { rows, enabled: rows.length > 0 }
+}
+
+// 行编辑态 → 提交载荷（percent → multiplier、预设 → days，含前置校验）。
+// error 非空=校验失败文案（提示方式由调用方决定，组件内走 Message.warning）
+export function timeSegmentPayloadFrom(rows: TimeSegmentRow[], enabled: boolean): { payload?: any[]; error?: string } {
+	if (!enabled) return { payload: [] }
+	if (rows.length === 0) {
+		return { error: '已开启时段定价，请至少添加一条时段' }
+	}
+	for (const [i, seg] of rows.entries()) {
+		if (!seg.name.trim()) {
+			return { error: `第 ${i + 1} 条时段名称不能为空` }
+		}
+		if (!seg.percent || seg.percent <= 0) {
+			return { error: `时段「${seg.name}」乘数必须大于 0` }
+		}
+		if ((seg.start_time ? 1 : 0) !== (seg.end_time ? 1 : 0)) {
+			return { error: `时段「${seg.name}」开始与结束时间需同时填写或同时留空` }
+		}
+		if (seg.dayPreset === 'custom' && seg.days.length === 0) {
+			return { error: `时段「${seg.name}」自定义适用日至少选择一天` }
+		}
+	}
+	return {
+		payload: rows.map((seg) => ({
+			name: seg.name.trim(),
+			days: seg.dayPreset === 'custom' ? [...seg.days].sort((a, b) => a - b) : presetToDays[seg.dayPreset] || [],
+			start_time: seg.start_time || '',
+			end_time: seg.end_time || '',
+			valid_from: seg.validRange?.[0] || '',
+			valid_to: seg.validRange?.[1] || '',
+			multiplier: (seg.percent || 0) / 100,
+		})),
+	}
+}
+</script>
+
+<script setup lang="ts">
+// 时段定价编辑器（主弹窗与官方定价弹窗共用）：
+// 按命名时段对基准价等比缩放，时段从上到下先命中先生效。
+// 数据数组由父级持有（reactive），编辑/校验/载荷逻辑内聚在本组件。
+import { computed } from 'vue'
+import { Message } from '@arco-design/web-vue'
+import { formatBilling } from '@/composables/useCurrency'
+
+const props = withDefaults(
+	defineProps<{
+		segments: TimeSegmentRow[]
+		previewBase?: SegmentPreviewBase | null
+		title?: string
+		hint?: string
+	}>(),
+	{
+		previewBase: null,
+		title: '时段定价',
+		hint: '全部价格（含各档位/缓存/按次价）按乘数等比缩放：100% = 默认价，未命中时段按默认价',
+	},
+)
+
+// 开关：父级可 v-model:enabled；关闭时段不参与提交
+const enabled = defineModel<boolean>('enabled', { default: false })
+
+const dayPresetOptions = [
+	{ label: '每天', value: 'every' },
+	{ label: '工作日', value: 'weekday' },
+	{ label: '周末', value: 'weekend' },
+	{ label: '自定义', value: 'custom' },
+]
+
+const weekdayOptions = [
+	{ label: '周一', value: 1 },
+	{ label: '周二', value: 2 },
+	{ label: '周三', value: 3 },
+	{ label: '周四', value: 4 },
+	{ label: '周五', value: 5 },
+	{ label: '周六', value: 6 },
+	{ label: '周日', value: 7 },
+]
+
+// 预设/days 换算在前置块（timeSegmentRowsFromAPI / timeSegmentPayloadFrom 共用）
+
+function createEmptySegment(): TimeSegmentRow {
+	return { name: '', dayPreset: 'every', days: [], start_time: '', end_time: '', validRange: undefined, percent: 100 }
+}
+
+function addTimeSegment() {
+	props.segments.push(createEmptySegment())
+	if (!enabled.value) enabled.value = true
+}
+
+function removeTimeSegment(index: number) {
+	props.segments.splice(index, 1)
+}
+
+// 上移/下移：时段从上到下先命中先生效，促销时段应排在常驻时段之前
+function moveTimeSegment(index: number, offset: number) {
+	const target = index + offset
+	if (target < 0 || target >= props.segments.length) return
+	const [seg] = props.segments.splice(index, 1)
+	props.segments.splice(target, 0, seg)
+}
+
+function segmentDesc(seg: TimeSegmentRow): string {
+	const daysText =
+		seg.dayPreset === 'custom'
+			? seg.days.length
+				? [...seg.days]
+						.sort((a, b) => a - b)
+						.map((d) => '周' + '一二三四五六日'[d - 1])
+						.join('、')
+				: '每天'
+			: dayPresetOptions.find((o) => o.value === seg.dayPreset)?.label || '每天'
+	const timeText = seg.start_time && seg.end_time ? `${seg.start_time}~${seg.end_time}` : '全天'
+	let rangeText = ''
+	if (seg.validRange?.[0]) {
+		rangeText = seg.validRange[1] ? `，${seg.validRange[0]}~${seg.validRange[1]}` : `，${seg.validRange[0]} 起`
+	}
+	return `${daysText} ${timeText}${rangeText}`
+}
+
+function segmentPreview(seg: TimeSegmentRow): string {
+	const m = (seg.percent || 0) / 100
+	const base = props.previewBase
+	if (!base) return `×${m}`
+	if (base.kind === 'per_second') {
+		return `${formatBilling((base.perSecond || 0) * m, 4)} /秒`
+	}
+	if (base.kind === 'per_request') {
+		return `${formatBilling((base.perRequest || 0) * m, 4)} /次`
+	}
+	const prefix = base.kind === 'tiered' ? '首档 ' : ''
+	return `${prefix}输入 ${formatBilling((base.input || 0) * m, 4)} · 输出 ${formatBilling((base.output || 0) * m, 4)}`
+}
+
+function defaultPreviewText(): string {
+	const base = props.previewBase
+	if (!base) return '—'
+	if (base.kind === 'per_second') {
+		return `${formatBilling(base.perSecond || 0, 4)} /秒`
+	}
+	if (base.kind === 'per_request') {
+		return `${formatBilling(base.perRequest || 0, 4)} /次`
+	}
+	const prefix = base.kind === 'tiered' ? '首档 ' : ''
+	return `${prefix}输入 ${formatBilling(base.input || 0, 4)} · 输出 ${formatBilling(base.output || 0, 4)}`
+}
+
+const hasSegments = computed(() => props.segments.length > 0)
+
+// 回显：multiplier → percent，days → 预设（委托前置块纯函数，与父级直接填充行数组共用换算）
+function loadTimeSegments(list: any[] | null | undefined) {
+	const conv = timeSegmentRowsFromAPI(list)
+	props.segments.length = 0
+	props.segments.push(...conv.rows)
+	enabled.value = conv.enabled
+}
+
+function resetTimeSegments() {
+	enabled.value = false
+	props.segments.length = 0
+}
+
+// 提交载荷：percent → multiplier，预设 → days（含前置校验，校验失败 Message 提示并返回 null）
+function buildTimeSegmentsPayload(): any[] | null {
+	const result = timeSegmentPayloadFrom(props.segments, enabled.value)
+	if (result.error) {
+		Message.warning(result.error)
+		return null
+	}
+	return result.payload ?? []
+}
+
+defineExpose({ loadTimeSegments, resetTimeSegments, buildTimeSegmentsPayload })
+</script>
+
+<template>
+	<div class="editor-section">
+		<div class="editor-section-header">
+			<h3>{{ title }}</h3>
+			<ASwitch v-model="enabled" size="small" />
+			<span class="section-hint">{{ hint }}</span>
+		</div>
+		<template v-if="enabled">
+			<div v-for="(seg, index) in segments" :key="index" class="tier-card">
+				<div class="tier-header">
+					<div class="segment-tools">
+						<AButton size="mini" :disabled="index === 0" @click="moveTimeSegment(index, -1)">↑</AButton>
+						<AButton size="mini" :disabled="index === segments.length - 1" @click="moveTimeSegment(index, 1)">↓</AButton>
+						<span class="tier-label">第 {{ index + 1 }} 条</span>
+					</div>
+					<AButton size="mini" status="danger" @click="removeTimeSegment(index)">删除</AButton>
+				</div>
+				<div class="grid grid-cols-2 md:grid-cols-4 gap-x-4">
+					<AFormItem label="时段名称">
+						<AInput v-model="seg.name" placeholder="如：闲时 / 工作忙时" :maxlength="32" allow-clear />
+					</AFormItem>
+					<AFormItem label="价格乘数">
+						<AInputNumber v-model="seg.percent" :min="1" :max="1000" :step="5" :precision="0" class="w-full">
+							<template #suffix>%</template>
+						</AInputNumber>
+					</AFormItem>
+					<AFormItem label="每日时段（留空 = 全天）" class="md:col-span-2">
+						<div class="time-range">
+							<ATimePicker v-model="seg.start_time" format="HH:mm" allow-clear placeholder="开始" class="w-full" />
+							<span class="time-sep">~</span>
+							<ATimePicker v-model="seg.end_time" format="HH:mm" allow-clear placeholder="结束" class="w-full" />
+						</div>
+					</AFormItem>
+				</div>
+				<div class="grid grid-cols-1 md:grid-cols-2 gap-x-4 mt-1">
+					<AFormItem label="适用日">
+						<ARadioGroup v-model="seg.dayPreset" type="button" size="small">
+							<ARadio v-for="opt in dayPresetOptions" :key="opt.value" :value="opt.value">{{ opt.label }}</ARadio>
+						</ARadioGroup>
+					</AFormItem>
+					<AFormItem label="有效期（促销/定时调价，可选）">
+						<ARangePicker v-model="seg.validRange" class="w-full" allow-clear />
+					</AFormItem>
+					<AFormItem v-if="seg.dayPreset === 'custom'" label="自定义星期" class="custom-days-item md:col-span-2">
+						<div class="custom-days">
+							<ACheckboxGroup v-model="seg.days" :options="weekdayOptions" />
+						</div>
+					</AFormItem>
+				</div>
+				<div class="segment-preview">{{ segmentDesc(seg) }} → {{ segmentPreview(seg) }}</div>
+			</div>
+			<AButton type="dashed" long class="mt-3" @click="addTimeSegment">+ 添加时段</AButton>
+			<div class="combo-preview-hint">时段从上到下先命中先生效：限时促销时段应排在常驻时段上方</div>
+
+			<!-- 组合预览：换算后的实际价格（父级未传基准价时不显示金额，仅倍率） -->
+			<div v-if="hasSegments" class="combo-preview">
+				<div class="combo-preview-title">价格预览（换算后实际价格）</div>
+				<div class="combo-row">
+					<span class="combo-name">默认价（未命中时段）</span>
+					<span class="combo-value">{{ defaultPreviewText() }}</span>
+				</div>
+				<div v-for="(seg, index) in segments" :key="index" class="combo-row">
+					<span class="combo-name">{{ seg.name || `时段 ${index + 1}` }}（{{ segmentDesc(seg) }}）</span>
+					<span class="combo-value">{{ segmentPreview(seg) }}</span>
+				</div>
+			</div>
+		</template>
+	</div>
+</template>
+
+<style scoped>
+/* 与主弹窗一致的 section / 卡片基础样式（scoped 隔离，组件内自持） */
+.editor-section {
+	margin-bottom: 24px;
+}
+
+.editor-section-header {
+	display: flex;
+	align-items: center;
+	gap: 12px;
+	margin-bottom: 12px;
+}
+
+.editor-section-header h3 {
+	font-size: 14px;
+	font-weight: 600;
+	color: var(--ta-text-primary);
+	margin: 0;
+}
+
+.section-hint {
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+}
+
+.tier-card {
+	padding: 12px 16px;
+	background: var(--color-fill-1);
+	border-radius: 8px;
+	margin-bottom: 8px;
+}
+
+.tier-header {
+	display: flex;
+	justify-content: space-between;
+	align-items: center;
+	margin-bottom: 8px;
+}
+
+.tier-label {
+	font-size: 13px;
+	font-weight: 600;
+	color: var(--ta-text-secondary);
+}
+
+.combo-value {
+	color: var(--ta-text-primary);
+	font-family: monospace;
+	text-align: right;
+}
+
+.segment-tools {
+	display: flex;
+	align-items: center;
+	gap: 4px;
+}
+
+.time-range {
+	display: flex;
+	align-items: center;
+	gap: 8px;
+}
+
+.time-sep {
+	color: var(--color-text-3);
+}
+
+.custom-days {
+	display: flex;
+	flex-wrap: wrap;
+	gap: 4px 12px;
+}
+
+.segment-preview {
+	margin-top: 4px;
+	padding: 6px 10px;
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+	background: var(--color-fill-2);
+	border-radius: 4px;
+}
+
+.combo-preview {
+	margin-top: 10px;
+	padding: 10px 14px;
+	background: var(--color-fill-1);
+	border: 1px solid var(--ta-border-light);
+	border-radius: 8px;
+}
+
+.combo-preview-title {
+	font-size: 12px;
+	font-weight: 600;
+	color: var(--ta-text-secondary);
+	margin-bottom: 6px;
+}
+
+.combo-row {
+	display: flex;
+	align-items: baseline;
+	justify-content: space-between;
+	gap: 12px;
+	padding: 3px 0;
+	font-size: 12px;
+}
+
+.combo-preview-hint {
+	margin-top: 6px;
+	font-size: 12px;
+	color: var(--ta-text-tertiary);
+}
+</style>