diff --git a/README.md b/README.md
index 0b63be6..5a827fc 100644
--- a/README.md
+++ b/README.md
@@ -171,12 +171,14 @@ plugins:
 
 重置统计入口只在完整模式可用，需要当前完整模式会话和显式确认。
 
-表格偏好、Token 显示单位和时间范围保存在插件数据库中。`token_display_mode` 支持 `full`、`k`、`m`、`B`，普通模式和完整模式共用该偏好。自定义时间按浏览器本地时区选择，再转换为 UTC RFC3339 时间戳请求。
+表格偏好、Token 显示单位和时间范围保存在插件数据库中。`token_display_mode` 支持 `full`、`k`、`m`、`B`，普通模式和完整模式共用该偏好。自定义时间按浏览器本地时区选择，再转换为 UTC RFC3339 时间戳请求。页面打开或刷新时，如果距离上次成功打开已满 15 分钟，保存的时间范围会自动恢复为浏览器本地当天；15 分钟内重新打开则保留原选择。该打开时间与日期范围一样由同一插件数据库共享。
 
 ### 模型价格与费用估算
 
 模型价格入口只在完整模式显示。所有价格单位均为每 100 万 Token 的美元价格，支持 Input、Output、Cache Read、Cache Creation、Context Tier、Service Tier 独立价格及其 Context Tier，以及 `input_excludes_cache` 和 `input_includes_cache` 两种计费方式。所有价格为 0 的模型按免费模型处理。
 
+支持在模型的“峰谷定价”折叠区配置时区、星期和时间段（最多 32 个），按请求原始时间选价。未命中时使用基础或 Service Tier 价格；Context Tier 优先于时间价格。跨午夜归属起始日，时间区间包含开始、不包含结束。修改配置会重新估算历史费用。详见 [峰谷定价说明](docs/issue-78-time-of-use-pricing-plan.md)。
+
 价格可手工维护，也可从 models.dev 同步。同步先读取 CLIProxyAPI `/v1/models` 当前返回的模型，再根据提供商优先级、忽略后缀和显式模型映射匹配 models.dev。
 
 手工价格优先，不会被同步覆盖。价格簿使用 revision 防止并发覆盖。费用根据逐请求记录和匹配的价格规则计算；缺价请求会显示在价格覆盖率和缺价提示中，不会作为零成本混入已知费用。
@@ -468,7 +470,7 @@ Without an explicit `data_path`, the plugin resolves the database in this order:
 
 Both modes support preset or custom date-time ranges, source filtering, trend granularity and zoom, model drill-down, full, k, m, or B token units (`B = 1,000,000,000`), currency units, table columns and sorting, manual refresh, 15-second automatic refresh, and preset/custom table page sizes. Statistics reset is available only in full mode and requires the active session plus explicit confirmation.
 
-Table preferences, the selected token display unit, and the selected range are stored in the plugin database. `token_display_mode` accepts `full`, `k`, `m`, or `B`, and normal and full modes share the preference. Custom browser-local times are converted to UTC RFC3339 timestamps for requests.
+Table preferences, the selected token display unit, and the selected range are stored in the plugin database. `token_display_mode` accepts `full`, `k`, `m`, or `B`, and normal and full modes share the preference. Custom browser-local times are converted to UTC RFC3339 timestamps for requests. On open or reload, if at least 15 minutes have elapsed since the last successful open, the saved range resets to the browser's local today; reopening within 15 minutes keeps the saved range. The open timestamp, like the selected range, is shared by clients using the same plugin database.
 
 ### Model Pricing and Cost Estimation
 
diff --git a/docs/issue-78-time-of-use-pricing-plan.md b/docs/issue-78-time-of-use-pricing-plan.md
new file mode 100644
index 0000000..6189f63
--- /dev/null
+++ b/docs/issue-78-time-of-use-pricing-plan.md
@@ -0,0 +1,63 @@
+# Issue #78：模型峰谷定价
+
+对应 https://github.com/AITNR/cap-token-usage-tracker/issues/78 。
+
+## 实现范围
+
+完整模式的模型价格编辑器新增峰谷定价折叠区。模型可配置 IANA 时区、时段名称、ISO 星期编号（1=星期一，7=星期日，留空为每天）、开始和结束时间，以及四项 USD/百万 token 单价。
+
+- 每个模型最多 32 个时段；名称唯一，时段不允许重叠。
+- 时间严格使用 HH:mm，起止相同被拒绝，不支持 24:00。
+- 区间左闭右开；23:00–08:00 表示跨午夜，并归属起始日。例如星期日的该时段延续到星期一 08:00。
+- 默认 UTC；禁止依赖机器的 Local 时区。内嵌 Go 时区数据，支持 Windows 和精简容器。
+- 夏令时重复小时按当地钟表时间匹配，两次均适用；跳过的小时没有对应请求时刻。
+- 按保存的请求时间选价，沿用上游缺少 RequestedAt 时的接收时间兜底，无法据此保证与供应商账单完全一致。
+
+## 价格优先级
+
+先匹配模型和 Service Tier，再应用时间价格，最后应用 Context Tier。时间价格覆盖四项单价；Context Tier 超阈值时覆盖时间价格。这一版不支持时间段内嵌上下文阶梯。
+
+未命中使用基础/Service Tier 价格。请求费用提示和 CSV 增加计费时段、计费时区；当 Context Tier 实际覆盖时间价格时，不将时间段标为最终计费依据。
+
+## 示例
+
+以下仅为测试示例，不代表 DeepSeek 当前官方价格：
+
+```json
+{
+  "prices": {
+    "example-model": {
+      "input": 4,
+      "output": 8,
+      "cache_read": 1,
+      "cache_creation": 0,
+      "time_zone": "Asia/Shanghai",
+      "time_tiers": [
+        {
+          "name": "谷时",
+          "start": "23:00",
+          "end": "08:00",
+          "input": 1,
+          "output": 2,
+          "cache_read": 0.25,
+          "cache_creation": 0
+        }
+      ]
+    }
+  }
+}
+```
+
+## 持久化、同步与兼容性
+
+扩展现有价格账本 JSON，无请求记录迁移。没有时间字段的旧配置继续有效。保存增加价格账本 revision，历史请求查询与成本汇总按当前配置重新估算。
+
+沿用手动价格整条保护：编辑时间计划后该模型成为手动价格，models.dev 同步不会更新其基础价格。对于仍标记 models.dev 的条目，同步更新基础价格时保留已有时间计划。没有新增同步计数字段，手动条目继续计入 SkippedManual。
+
+旧程序不认识这些 JSON 字段；降级后重新保存价格可能丢失时间计划，降级前应备份数据库。
+
+## 验证
+
+Go 测试覆盖分钟边界、跨周午夜、星期限制、夏令时重复小时、非法配置、深拷贝、价格优先级、同步保留、历史查询缓存失效和重启持久化。浏览器回归覆盖时段输入、表单序列化回填、重叠拒绝和删除。
+
+仓库没有 npm test；浏览器测试由 Go 调用 Playwright。Windows 上设置 CHROME_PATH 和 REQUIRE_BROWSER_TESTS=1 后执行 go test ./...。依赖使用 npm ci 安装，不下载浏览器。
diff --git a/docs/issue-80-startup-cost-elimination-plan.md b/docs/issue-80-startup-cost-elimination-plan.md
new file mode 100644
index 0000000..30e78f5
--- /dev/null
+++ b/docs/issue-80-startup-cost-elimination-plan.md
@@ -0,0 +1,178 @@
+# Issue #80 启动成本消除实施计划
+
+- Issue: https://github.com/AITNR/cap-token-usage-tracker/issues/80
+- 基础方案：`docs/issue-80-startup-readiness-fix-plan.md`（生命周期 readiness 与异步化设计）
+- 目标：让插件启动不再随历史聚合数据和逐请求记录规模线性增长，同时保持现有 API 统计语义。
+- 文档性质：实施规格与验收清单；实现时以本文为约束，不将本文内容当作对外部宿主契约的证明。
+- 当前代码基线：工作区 `persistence.go` 的 schema v10/API Key catalog 改动；实施者开始前必须重新检查 git 状态和实际代码，保留所有既有改动。
+
+## 1. 目标与架构决策
+
+当前稳定 schema 已通过 API Key catalog 消除 `reload()` 对 `requests` 桶的扫描，但 `reload()` 仍将保留期内的全部聚合记录读入 `a.data`。本计划将全量内存恢复改为**热窗口驻留 + actor 内按需范围读取**，并修复 catalog 的损坏恢复策略。
+
+本计划只承诺降低插件自身的数据库恢复成本；不承诺某个硬编码启动时限。CPA 是否等待注册完成、是否重试 usage RPC、是否允许 register 返回时 capability 尚未 ready，均须通过目标 CPA/SDK 版本验证。未经验证不得依赖异步注册或 usage 503 重试。
+
+架构边界：
+
+1. Actor 仍是 store 状态与数据库访问的唯一串行入口。查询、flush、prune、reset 和范围读通过 actor 命令协调；不得从新 goroutine 绕过 actor 并发读写 `a.data` 或同一个 `bolt.DB`。
+2. bbolt 聚合桶名当前为 `hours`，但其 key 实际是 `RequestedAt.UTC().Truncate(time.Minute).Unix()`。外层桶是**分钟聚合桶**，不是小时桶。所有范围边界、热窗口和性能估算都必须按分钟 key 处理；保留现有 bucket 名称以避免无关 schema 迁移。
+3. 热窗口是内存优化，不是数据可用性边界。查询范围超出热窗口必须由同一 actor 读取冷范围，并与内存中未 flush 的 dirty 聚合合并，结果不得不完整。
+4. catalog、models index 均是可重建派生数据；不得因其缺失/损坏而静默丢数据，也不得在 `register()` 同步路径无条件触发全量重建。
+
+## 2. 当前基线事实
+
+启动路径为 `openStoreWithCrypto()` -> `storeActor.initialize()` -> `reload()`。稳定 schema v10 下：
+
+- `reload()` 从 `meta` 恢复配置、价格、偏好和 API Key catalog；
+- `reload()` 遍历 `hours` 下所有保留分钟桶，反序列化维度与 counters 并填充 `a.data`；
+- `reload()` 不再扫描 `requests`；
+- schema 升级或 catalog 缺失时，`buildAPIKeyCatalog()` 仍需一次全量 backfill；
+- `flush()` 维护 catalog 与聚合、请求记录的事务一致性；prune 处理过期记录；
+- `observedModels()` 当前通过 `a.data` 枚举模型，热窗口化后若不另建索引会改变其保留期语义。
+
+这些事实实施前须用当前代码再次确认。不要依赖文档中的固定行号。
+
+## 3. 实施阶段
+
+### 阶段 0：基线、隔离与测量
+
+1. 检查 `git status`、当前分支和已有未提交改动；不得覆盖用户或先前任务变更。
+2. 保存当前测试基线，运行 `go test ./... -count=1` 和 `go vet ./...`。
+3. 建立可重复的合成 bbolt fixture：多个分钟、多个 dimension、多个 API Key、请求明细；至少包含热窗口内外数据。
+4. 记录现状 open 耗时、`reload()` 聚合解码条数、峰值内存。时间数据仅作为基准，不设环境无关的绝对毫秒承诺。
+
+验收：fixture 可复用、测试可确定性运行，基准能证明初始化扫描记录数。
+
+### 阶段 1：修复 catalog 派生索引可靠性
+
+1. 合并 `initialize()` 中 catalog load/build 两分支的重复 save；仅在构建、修复或确有变更时写入。
+2. 对 catalog 缺失、JSON 损坏、引用计数非法、引用 generation 无效分别定义行为。
+3. Catalog 是派生索引：损坏时不得直接把统计主库判为不可用；也不得在同步注册路径自动 full-scan 修复。
+4. 本阶段采用显式 degraded/rebuild-required 状态或维护入口。若完整 readiness 状态目前尚未实现，应让主统计和逐请求查询继续可用，同时禁用依赖不可信 catalog 的 API Key label/ciphertext 管理操作，并记录不含敏感数据的错误。禁止用空 catalog 覆盖损坏 catalog。
+5. 提供 actor 串行执行的显式 catalog rebuild 操作；rebuild 在 bbolt transaction 中从 hours/requests 重建并校验，成功后原子替换，失败时保留旧索引与错误状态。
+6. 增加 catalog format/version 或 generation 标记，使“有效空 catalog”和“缺失/损坏 catalog”可区分。
+7. 维持现有写入语义：aggregate/request 与 catalog 在同一 bbolt transaction 更新；transaction 成功后再更新 actor 内存副本。
+
+测试：valid empty catalog、missing、非法 JSON、非法计数、backfill 成功/失败、写事务回滚、prune、reset、restore、API Key generation 切换、label 引用关系。
+
+### 阶段 2：按需访问 observed models
+
+1. 保持 `ObservedModels()` 的现有语义：返回保留数据范围内出现过的模型，不允许悄悄缩成热窗口模型。
+2. 增加独立 `observed_models` 派生索引，在成功持久化新聚合时增量维护；索引更新与聚合写入同一事务。
+3. 过期分钟桶 prune 时，只有当模型的全部保留聚合引用都已移除后才删除模型。可以维护模型级计数，也可通过明确可控的重建策略；不得每小时扫描全量请求记录。
+4. 旧库模型索引缺失时，允许一次 rebuild，但要与 catalog 一样避免阻塞宿主注册；应由显式维护入口或异步 readiness 阶段协调。过渡期 `ObservedModels()` 可在索引不可用时执行明确可观察的兼容扫描，不能返回不完整集合。
+
+测试：旧模型超出热窗口但仍在 retention 内时仍可观察；模型所有聚合过期后消失；多 provider/model 组合、reset、restore 和索引 rebuild。
+
+### 阶段 3：定义 actor 内聚合范围数据源
+
+实现范围读取 helper/接口，供聚合查询统一使用。接口可以采用 `aggregateSource`，但必须满足：
+
+- 输入范围使用 UTC Unix minute key，边界严格遵守现有左闭右开语义；
+- bbolt cursor 从 `encodeInt64(start)` seek，到 `end` 前停止；处理空桶、非法 key、嵌套 bucket 的行为与现有校验一致；
+- 在 actor command 内读取，避免和 flush/reset/restore 并发；一次查询内的数据视图一致；
+- 查询合并内存 `a.dirty`/`a.data` 的未 flush 写入，避免漏掉近期记录或重复聚合；
+- 冷数据读取后默认不常驻内存；若增加 LRU，容量必须有界，且 reset/restore/reconfigure/prune 能正确失效；
+- 当前 `hours` 外桶是分钟粒度，不能按 24/168/720 个桶估算。24h、7d、30d 分别最多覆盖约 1,440、10,080、43,200 个分钟桶（受起止分钟、空桶影响）。
+
+优先保留基于 map 的 source 作为测试 oracle；bbolt source 与 map source 对同一 fixture 必须逐字段等价。
+
+### 阶段 4：迁移查询路径
+
+逐项让以下查询从范围 source 读取，不能只改首页主 stats：
+
+1. 完整 stats、summary、groups；
+2. initial stats；
+3. trends；
+4. 分页 groups；
+5. custom 秒级精确查询：仍以 requests 明细按精确时间重建，不得把分钟聚合误用于秒级边界；
+6. costs：保持现有按 request detail 的时间范围语义，避免错误复用分钟聚合导致价格/费用改变；
+7. CSV/导出及 Full Mode 使用的相同后端查询路径；
+8. `retention` 全量范围明确允许全量范围读，结果必须完整。它可能仍然慢，应作为独立性能问题测量，不得以截断热窗口数据冒充完整结果。
+
+UI/API schema 与统计口径保持不变。若某范围确实需要异步/分块响应，须另行设计并明确响应契约，本阶段不静默返回部分结果。
+
+### 阶段 5：热窗口化 reload 与写入协调
+
+1. 配置 `hot_window` 可暂不公开为用户配置；优先选择常量或内部默认值，以减少配置兼容面。窗口以时间长度表达，映射为分钟范围。
+2. `reload()` 只把 `[now-hotWindow, now]` 的分钟聚合载入 `a.data`；冷数据留在 bbolt。
+3. 初始化/恢复期间需确保窗口下界之前的数据仍可由范围 source 查询。
+4. 新 usage 正常进入 actor 内存；即便 RequestedAt 落在热窗口之前或未来，必须遵循现有接受/保留边界，并保证查询结果不丢不重。迟到事件不得因只缓存 hot window 而无法 flush 或 catalog 计数错误。
+5. `persistedAggregates` 只跟踪内存中热窗口内实际加载并持久化的 keys；冷范围查询不得错误修改 dirty/persisted 状态。
+6. prune 需删除数据库中过期分钟桶，并同步删除内存中对应 key、model 索引引用、API Key catalog 引用；冷数据不在内存时仍必须正确完成。
+
+### 阶段 6：异步 readiness（可选安全网，契约门控）
+
+只有在检查目标 CLIProxyAPI/SDK 版本后确认 register 和 RPC 契约，才可实现以下内容：
+
+- `register()` 快速返回与 `starting/ready/failed` readiness；
+- 所有依赖 store 的 endpoint 行为；
+- usage during startup 的严格拒绝、重试或持久化队列策略；
+- shutdown/reconfigure/restore 的取消与 handover。
+
+若 usage RPC 失败不保证重试，禁止仅返回 503 并声称无数据丢失；若实现队列，必须有界/持久、保持顺序、可观测、在 shutdown 时不丢且有回放幂等方案。若本阶段宿主契约无法确认，则不实施异步注册，并在交付说明标明；前述同步路径仍须通过范围加载降低成本。
+
+## 4. 必须覆盖的状态与操作
+
+实现者须逐一盘点并处理：
+
+- store open / reopen / reconfigure / shutdown；
+- flush、sync_on_record、定时 flush、retention prune；
+- backup / restore / staged migration / rollback；
+- reset；
+- API Key rotation、labels、ciphertext catalog；
+- ObservedModels；
+- stats、groups、initial、trends、requests、costs、export、Full Mode；
+- 空库、旧 schema、非法索引、部分索引、数据库读写错误。
+
+不得因范围加载而改变公开统计结果、失败计数、维度过滤、source 过滤、exact custom 范围、价格账本、保留期或 API Key 脱敏语义。
+
+## 5. 测试与验证
+
+### 正确性
+
+1. 对合成数据库保留旧全量 map 结果作为 oracle，比较 `24h`、`7d`、`30d`、custom、retention 的 stats/initial/trend/groups 所有字段。
+2. 分钟边界：start/end 落在分钟中间、刚好边界、跨日/月/epoch 前后；验证左闭右开。
+3. 写入协调：dirty 未 flush、sync_on_record、迟到 usage、flush 同时查询、prune 边界。
+4. catalog/models 索引：缺失、损坏、重建失败与成功、恢复、reset、rotation、过期清理。
+5. exact custom 秒级查询和成本查询必须继续读取 requests，并与当前实现逐字段一致。
+6. 并发与生命周期：关闭、重配置、restore 与查询冲突时无死锁、数据竞争、重复计数或句柄泄漏。
+
+### 性能
+
+合成 fixtures 覆盖小库、十万级与百万级聚合/请求记录；报告：
+
+- open/reload 耗时；
+- `reload()` 解码的聚合记录数量，应与热窗口记录量相当而不是 retention 总量；
+- 稳定 schema reopen 不解码 requests；旧库索引 rebuild 单独测量；
+- 首次 24h/7d/30d/retention 查询耗时；
+- 峰值 RSS；
+- catalog/model index rebuild 的耗时与失败行为。
+
+不设跨设备的绝对毫秒门槛。核心验收是稳定启动路径的扫描数量受热窗口约束，且完整范围查询结果不变。
+
+### 命令
+
+```powershell
+go test ./internal/plugin -count=1
+go test ./... -count=1
+go vet ./...
+git diff --check
+```
+
+若执行 race test 需要 CGO 且环境没有可用 C 编译器，应明确报告环境限制，不得把未运行写成通过。
+
+## 6. 实施顺序与交付
+
+建议依次完成阶段 0–5，再依据宿主契约决定阶段 6。按需范围读取和热窗口改造涉及 `persistence.go`、`aggregate.go`、`cost.go` 与测试，实施期间避免并行代理修改同一文件。
+
+实现者完成后报告：
+
+- 变更文件和各阶段完成情况；
+- 性能前后测量及记录数证据；
+- 全量语义一致性测试结果；
+- 未完成阶段及原因；
+- CPA/SDK 契约实际验证来源；
+- 环境限制和剩余风险。
+
+验收的最低标准：启动不再反序列化 retention 范围全部聚合记录；稳定 schema 不扫描 requests；所有公开查询仍返回完整且与原实现等价的结果；索引损坏不会静默破坏主数据或同步触发无界扫描；所有生命周期路径测试通过。
diff --git a/docs/issue-80-startup-readiness-fix-plan.md b/docs/issue-80-startup-readiness-fix-plan.md
new file mode 100644
index 0000000..e3bfa59
--- /dev/null
+++ b/docs/issue-80-startup-readiness-fix-plan.md
@@ -0,0 +1,158 @@
+# Issue #80 修复方案：降低大 bbolt 数据库的启动阻塞
+
+- Issue：<https://github.com/AITNR/cap-token-usage-tracker/issues/80>
+- 文档性质：基于当前工作区代码的修复设计与已实施核心修复记录。存储层 catalog/backfill、稳定 reopen 和周期 prune 优化已落地；异步 readiness 仍未实现。
+- 证据边界：Issue #80 报告了插件 `v2.0.8`、CLIProxyAPI `v8.0.4`、Linux amd64、约 1.8 GiB 数据库及约 8 分钟启动现象。这些是报告环境，不是本地复现实测结果。下文的函数、控制流和遍历结论来自当前工作区；宿主 RPC 的异步注册契约仍需在目标 CPA 版本上验证。
+
+## 1. 已确认的调用链与扫描事实
+
+当前注册路径是同步的：
+
+```text
+pluginRuntime.register()
+  -> applyConfig()
+     -> openStoreWithCrypto()
+        -> storeActor.initialize()
+           -> bbolt Update：清理、迁移、generation 状态
+           -> storeActor.reload()
+```
+
+`internal/plugin/lifecycle.go` 中的 `register()` 在 `lifecycleMu` 保护下调用 `applyConfig()`；数据路径需要打开新 store 时，`openStoreWithCrypto()` 会在返回前执行 `actor.initialize()`。因此，`initialize()` 的耗时处于本插件注册请求的同步路径。Issue #80 进一步报告 CPA 会等待该注册完成后才进入 ready；这是待在实际 CPA/SDK 版本上回归确认的宿主行为。
+
+### 1.1 启动时 `requestsBucket` 的已确认成本
+
+`internal/plugin/persistence.go` 的 `initialize()` 会先执行一次写事务：
+
+1. `pruneRequestsBucket()` 用按时间和序号排序的 request key 游标删除过期前缀；它在遇到首个未过期 key 后 `break`，因此不是必然读取全部保留 request value，也不会在该函数中 JSON 解码 `RequestDetail`。过期记录很多时，删除成本仍可能显著。
+2. `migrateAPIKeyCryptoSchema()` 在 `version >= 8` 时调用 `validateAPIKeyGenerationReferences(hours, requests, generations)`。该校验遍历 `requests` 并 JSON 解码每条 `RequestDetail`，同时遍历小时聚合维度。即使没有新的 schema 迁移，当前代码路径仍会执行此校验。
+3. 写事务完成后 `reload()` 再次调用同一个 `validateAPIKeyGenerationReferences()`，再次全量遍历并解码当前保留的 request records。
+4. `reload()` 之后独立执行 `requests.ForEach`，第三次遍历并 JSON 解码每条 request，用于重建 `a.apiKeyCiphertexts`，并把 request 引用补入 `retainedHashes`。
+
+因此，对 schema 已处于 `>= 8` 的常规启动，清理过期前缀之后，当前代码至少存在 **三次** 对保留 `requestsBucket` 的全量 JSON 解码遍历：迁移函数内 generation 引用校验、`reload()` 内重复校验和 `reload()` 的 ciphertext/引用重建。这个结论不依赖对单条记录大小或记录数量的估算。
+
+不能仅凭该结论断言 Issue 中约 8 分钟全部由这三次遍历造成：数据库页缓存、磁盘性能、bbolt 写入/删除、其他迁移和聚合桶数量同样会影响总耗时，应通过阶段计时和基准测试量化。
+
+### 1.2 周期 prune 的已确认成本
+
+`reload()` 把 `lastPruneAt` 重置为零值。actor 的下一次 flush tick 会计算 `shouldPrune := lastPruneAt.IsZero() || now.Sub(lastPruneAt) >= time.Hour`，所以初始化后的**首个 scheduled flush**会进入 prune 分支；具体等待时长等于实际 `FlushInterval`，不能在本方案中假设为固定秒数。
+
+该分支会：
+
+1. 调用 `pruneHoursBucket()`；当前实现对所有顶层小时 bucket 执行 `ForEach`，收集过期 bucket 后删除。
+2. 调用 `pruneRequestsBucket()`；它只扫描并删除过期 request key 前缀。
+3. 调用 `retainedAPIKeyState(hours, requests)`；该函数遍历全部保留小时聚合维度，并遍历、JSON 解码全部保留 request records，重建保留的 API Key 引用集合与 ciphertext map。
+4. 根据该集合删除失效 label，并把新的 ciphertext/label 状态发布回 actor。
+
+因此，除启动时的重复扫描外，首次 flush 以及其后满足一小时间隔的 prune 都会对保留 request records 再做一次全量解码遍历。
+
+## 2. 必须保留的语义与约束
+
+优化不能简单删掉 request 扫描：
+
+- API Key 引用由 `APIKeyGeneration` 和 `APIKeyHash` 共同组成；generation 记录在 `meta` 中，label 也存于 `meta`。
+- usage 记录路径会把启用 crypto 时的 API Key 转为 ciphertext，并把 ciphertext 随 `RequestDetail` 写入 `requests`。当前启动与 prune 正是从 request records 重建 `a.apiKeyCiphertexts`。
+- 当前 label 保留逻辑使用小时聚合和逐请求记录引用的并集。只从 `hours` 推断保留引用会改变现有语义，除非先用测试证明两者在所有兼容版本、迁移和异常恢复场景中严格等价。
+- generation 引用校验是损坏/不兼容数据的保护。若从普通启动移除全库校验，必须保留 schema 升级、备份 restore 和显式完整性检查中的完整校验路径。
+- `reconfigure`、backup、restore、store lease 和 `sync_on_record` 的现有行为均依赖 actor 的同步持久化边界，不能为了加速启动而发布半初始化状态或伪造写入成功。
+
+## 3. 推荐修复：先做同步存储层去重与索引化
+
+先减少明确存在的 I/O 和解码，而不是先改变宿主生命周期。这样可降低常规启动与周期 prune 成本，同时不假定 CPA 接受异步 `register()`。
+
+### 3.1 消除同一次启动中的重复 generation 校验
+
+将 API Key generation 引用校验拆为两个明确语义：
+
+- **迁移/导入完整校验**：当数据库从需要重写 API Key 引用的旧 schema 升级、执行 restore 后验证，或管理员显式请求完整性检查时，保留一次覆盖 `hours` 和 `requests` 的完整校验。
+- **常规 reopen**：已处于当前 schema 的本地数据库不得在 `migrateAPIKeyCryptoSchema()` 与紧随其后的 `reload()` 各进行一次完整校验。实现可以将本次初始化已经完成的验证结果传给 reload，或让 migration 函数在没有 schema 工作时不再做验证；两者择一，但必须保证常规 reopen 的完整 request 校验至多一次，最好结合 3.2 变为零次。
+
+不要使用静默忽略错误的方式替代校验。若选择跳过常规 reopen 的完整校验，必须把完整校验暴露为可诊断、可运行且可测试的维护/restore 路径，并记录为什么该数据库被视为已完成迁移。
+
+### 3.2 持久化 API Key catalog，替代常规 request 全表重建
+
+新增 versioned `meta` catalog，例如以 `generation + hash` 为 key，保存当前行为所需的最小状态：ciphertext、是否仍被小时聚合引用、是否仍被 request 明细引用，以及迁移版本或完整性状态。名称和编码在实现阶段确定。
+
+写入与删除必须与原始 bucket 更新在同一 bbolt 写事务中：
+
+- flush 写入小时聚合和 pending requests 时，更新对应引用及最新 ciphertext。
+- prune 删除过期小时 bucket 或 request record 时，基于即将删除的 key/value 更新相应来源的计数或引用状态。只解码被删除的过期记录；不得重新扫描全部未过期 records。
+- 当两个来源都不再引用某个 ref 时，再清理 catalog 中的 ciphertext，并按与当前 `retainedAPIKeyState()` 相同的并集规则清理 `apiKeyLabelsKey`。
+
+对已有数据库，不能假设从最新少量 request 倒序就能找到所有仍保留的 API Key：长期未使用但仍在保留期内的 key 是合法情况。首次引入 catalog 时应采用以下两种明确策略之一：
+
+1. **同步一次性 backfill**：完整扫描当前保留 hours 与 requests，原子写入 catalog；首次升级仍可能慢，但之后的正常重启与 prune 不再扫描全部 request records。必须提供阶段日志和测试。
+2. **受控后台 backfill**：仅在确认 CPA 对 readiness、usage 和失败状态的契约后使用。backfill 完成前不得根据不完整 catalog 清理 label/ciphertext，也不得把数据称为 ready。
+
+推荐先实现策略 1，因为它不改变注册/错误语义，风险最小。
+
+### 3.3 避免初始化后立即重复 prune
+
+`initialize()` 已按当前 cutoff 清理 hours 和 requests。成功完成 reload 后，可将 `lastPruneAt` 设为该初始化使用的时间，而不是保留零值，避免首个 scheduled flush 无条件重复一次 prune。
+
+该改动的前提是初始化成功执行了与 flush 等价的 retention/catalog 清理；如果初始化失败、配置在中间变更或 catalog backfill 未完成，则必须保留零值或显式标记为需要 prune。
+
+### 3.4 对 hours prune 的谨慎优化
+
+`pruneHoursBucket()` 当前遍历全部顶层 hour buckets。若 hour key 的编码和 bbolt 排序已由单元测试证明为按时间单调递增，可改为 cursor 从最早 hour 走到 cutoff 后立即停止，以避免检查保留期内的小时 bucket。
+
+此优化在实施前必须加入包含负/正时间边界的排序测试；没有该证明时，不应仅凭 `encodeInt64` 的名称假设可安全 early break。
+
+## 4. 阶段日志与可验证的性能目标
+
+在修改前后都应对以下阶段采集结构化日志/metrics：`open_db`、`prune_hours`、`prune_requests`、`migration`、`validate_api_key_refs`、`load_hours`、`load_requests`、`catalog_backfill` 和总初始化耗时。至少记录 duration、bucket/record count、是否为首次 catalog backfill、schema version 与结果；不得记录明文 API Key、ciphertext、请求正文或凭据。
+
+不要承诺固定的 200ms 或 50ms 启动时间：当前仓库没有可复现的 1.8 GiB 基准数据库、宿主计时和存储硬件数据。应采用下列可验收目标：
+
+1. catalog 已存在且数据库 schema 已稳定的普通 reopen，对未过期 `requestsBucket` 的完整 JSON 解码遍历次数为 **0**；允许仅扫描过期 key 前缀和实际写入/删除的 records。
+2. 同一合成 fixture 上，记录修复前后 `register()` 返回时间与各阶段耗时，报告 median 和 p95；不将未测得的绝对时延写入 release 承诺。
+3. 首次 catalog backfill 单独计时，且完成后第二次 reopen 满足目标 1。
+4. 加入数据库大小、request 数量、hours 维度数、保留期和冷/热缓存状态，以便结果可解释。
+
+## 5. 异步 readiness：后续增强，非本期前提
+
+Issue #80 建议让 `register()` 快速返回、后台加载数据库、管理接口返回 503。该方向有价值，但在本仓库中尚不能证明 CPA 的 plugin RPC 协议允许注册成功后再异步发布依赖 store 的能力，也不能证明宿主会如何重试 usage 或处理 503。
+
+在实施前必须针对目标 CPA/SDK 版本验证：
+
+- `register()` 返回成功后，宿主是否允许插件仍处于 starting；
+- usage 回调和管理路由的并发/重试/超时契约；
+- reconfigure、shutdown、restore 与后台打开同一 bbolt 路径时的句柄和 lease 规则；
+- 管理 API 的路由注册时点，以及 503 是否会被 dashboard/宿主正确呈现。
+
+只有通过这些验证后，才考虑带 generation 和取消机制的 `starting -> ready | failed` 状态机。初始化期间 usage 的策略必须明确为有界队列或拒绝并返回可识别错误；绝不能在尚未持久化时返回成功。即使采用异步 readiness，3.1 至 3.3 的存储层优化仍然需要保留，因为后台全表扫描会继续消耗 I/O 并延迟 ready。
+
+## 6. 实施顺序
+
+1. 为现有路径加入阶段计时和扫描计数，建立小库、合成大库与升级 fixture 的基线。
+2. 编写 catalog 编码、事务更新与完整 backfill；先保持 actor 生命周期同步。
+3. 调整 normal reopen 的 generation 校验策略，保留升级、restore 和显式完整性检查的全量验证。
+4. 用 catalog 替换 `reload()` 与周期 prune 中对全部未过期 request records 的重建扫描。
+5. 仅在排序测试通过后优化 `pruneHoursBucket()`，并让成功初始化抑制首次无条件周期 prune。
+6. 完成兼容/性能验证后，再单独设计和评审异步 readiness。
+
+## 7. 测试与验收
+
+### 功能与兼容性
+
+- 旧 schema 升级、当前 schema reopen、空库、损坏 generation 引用、缺失/损坏 catalog、backup/restore、reconfigure、shutdown 与 store handover。
+- 多 generation、相同 hash 的不同 generation、label 存在/过期、ciphertext 仅来自历史 request、小时与 request 引用不一致的 fixture。
+- request 或 hour prune 后 catalog、label、ciphertext 与当前 `retainedAPIKeyState()` 的结果完全一致。
+- `sync_on_record`、Query、RequestDetails、成本计算、导出和 dashboard 的既有结果不回归。
+
+### 扫描与性能
+
+- 对预填充大量未过期 request 的普通 reopen，使用测试 hook、受控 wrapper 或阶段计数断言：不调用全量 request `ForEach`/全量 RequestDetail JSON 解码。
+- 对首次 catalog backfill，断言完整扫描只发生一次；关闭再打开后不重复。
+- 对周期 flush，断言无写入但到 prune 时不会扫描所有未过期 request records；只处理过期前缀和必要 catalog 更新。
+- 跑完整 Go 测试套件，并在可用的 CPA 集成环境中记录 Issue 复现步骤的启动阶段日志。
+
+### 已执行验证与发布前验收标准
+
+- 修复后普通 reopen 的 request 全量解码遍历为零，首次 backfill/完整性检查例外且明确可观察。
+- API Key labels、ciphertexts 和 generation 引用的保留语义与当前实现等价。
+- 没有遗留 bbolt 句柄、lease、数据竞争、伪成功 usage 或 schema 兼容性破坏。
+- 已执行 `go test ./internal/plugin -count=1`、针对性 catalog/prune/API Key 测试和 `go test ./... -count=1`；未验证的 CPA 异步行为不作为已实现事实发布。
+
+## 8. 已实施范围与剩余工作
+
+本次实际修改了 `internal/plugin/persistence.go` 与 `internal/plugin/persistence_test.go`：新增 schema v10 的 `api_key_catalog` 元数据，旧 schema/缺失 catalog 首次打开时完整 backfill；稳定 reopen 从 catalog 恢复 API Key ciphertext，不再对保留 `requestsBucket` 全量 JSON 解码；周期 prune 只解码即将删除的过期 request，并增量维护 hours/request 引用计数；保留 restore 路径的完整校验。未修改宿主 RPC 或异步 readiness。
diff --git a/internal/plugin/cost.go b/internal/plugin/cost.go
index 744a5cb..adc987f 100644
--- a/internal/plugin/cost.go
+++ b/internal/plugin/cost.go
@@ -13,6 +13,8 @@ import (
 
 // EstimatedCost is calculated from one persisted request using the current model price.
 type EstimatedCost struct {
+	PriceTimeTier         string  `json:"price_time_tier,omitempty"`
+	PriceTimeZone         string  `json:"price_time_zone,omitempty"`
 	Priced                bool    `json:"priced"`
 	Source                string  `json:"source,omitempty"`
 	AccountingMode        string  `json:"accounting_mode,omitempty"`
@@ -119,6 +121,19 @@ type modelPriceResolver struct {
 
 // newModelPriceResolver builds the normalized fallback index once per price-book snapshot.
 func newModelPriceResolver(prices map[string]ModelPrice, settings PriceSyncSettings) modelPriceResolver {
+	prices = cloneModelPrices(prices)
+	for name, price := range prices {
+		if len(price.TimeTiers) > 0 {
+			zone := price.TimeZone
+			if zone == "" {
+				zone = "UTC"
+			}
+			if zone != "Local" {
+				price.timeLocation, _ = time.LoadLocation(zone)
+			}
+			prices[name] = price
+		}
+	}
 	resolver := modelPriceResolver{exact: prices}
 	normalizedSettings, err := normalizePriceSyncSettings(settings)
 	if err != nil {
@@ -438,16 +453,25 @@ func estimateRequestCostWithResolver(request RequestDetail, resolver modelPriceR
 		contextTiers = schedule.ContextTiers
 		priceServiceTier = serviceTier
 	}
+	timeTier, timeZone := "", ""
+	if tier, ok := selectTimePriceTier(price, request.Time); ok {
+		rates = tier.TokenRates
+		timeTier = tier.Name
+		timeZone = price.TimeZone
+	}
 	var selectedThreshold uint64
 	for _, tier := range contextTiers {
 		if contextTokens > tier.Threshold && tier.Threshold >= selectedThreshold {
 			rates = tier.tokenRates()
+			timeTier, timeZone = "", ""
 			selectedThreshold = tier.Threshold
 		}
 	}
 
 	result := EstimatedCost{
 		Priced:                true,
+		PriceTimeTier:         timeTier,
+		PriceTimeZone:         timeZone,
 		Source:                price.Source,
 		AccountingMode:        mode,
 		PriceServiceTier:      priceServiceTier,
diff --git a/internal/plugin/dashboard.go b/internal/plugin/dashboard.go
index 0a346d2..2f4ad46 100644
--- a/internal/plugin/dashboard.go
+++ b/internal/plugin/dashboard.go
@@ -248,7 +248,7 @@ html{background:#151412;color-scheme:dark}
 html:not([data-theme]){background:#faf9f5;color-scheme:light}
 html[data-theme='white']{background:#fff;color-scheme:light}
 html[data-theme='dark']{background:#151412;color-scheme:dark}
-</style>
+.time-pricing{grid-column:1/-1;padding:10px;border-top:1px solid var(--border-color)}.time-pricing summary{cursor:pointer}.time-pricing label{display:flex;flex-direction:column;gap:4px;min-width:0}.time-tier-row{display:grid;grid-template-columns:repeat(4,minmax(120px,1fr));gap:8px;padding:12px 0;border-bottom:1px solid var(--border-color)}.time-pricing input{width:100%;box-sizing:border-box}.time-pricing p{margin:8px 0}.time-pricing>.mini-button{margin-top:8px}@media(max-width:650px){.time-tier-row{grid-template-columns:repeat(2,minmax(100px,1fr))}}</style>
 <script>
 (function(){
 'use strict';
@@ -390,7 +390,7 @@ function shiftCalendarMonth(delta){var panels=document.getElementById('calendarP
 function applyRangePreset(mode){var range=presetDateRange(mode,new Date());draftRangeMode=mode;draftRangeStart=range.start;draftRangeEnd=range.end;calendarBaseMonth=new Date(draftRangeEnd.getFullYear(),draftRangeEnd.getMonth()-1,1);renderDateCalendars();}
 function confirmDateRange(){if(!draftRangeStart||!draftRangeEnd||draftRangeStart.getTime()>=draftRangeEnd.getTime())return;appliedRangeMode=draftRangeMode||'custom';appliedRangeStart=new Date(draftRangeStart);appliedRangeEnd=new Date(draftRangeEnd);updateRangeButton();updateGranularityForRange();resetTrendZooms();scheduleDashboardPreferencesSave();closeDateRange(true);load(true).catch(function(error){text('error',error.message);});}
 function resetDateRange(){var today=localDateOnly(new Date());draftRangeMode='custom';draftRangeStart=today;draftRangeEnd=new Date(today.getFullYear(),today.getMonth(),today.getDate()+1);calendarBaseMonth=new Date(today.getFullYear(),today.getMonth()-1,1);renderDateCalendars();}window.addEventListener('languagechange',function(){locale=detectLocale();formatterLocale=locale==='zh-CN'?'zh-CN':locale==='zh-TW'?'zh-TW':locale==='ru'?'ru-RU':'en-US';document.documentElement.lang=locale;moneyFormatters=Object.create(null);translateStatic();/*FULL_MODE_APIKEY_LANGUAGE*/if(currentData){renderVisuals();}if(currentRequestPage)renderRequests(currentRequestPage);updateTokenUnitButton();updateCurrencyButton();if(pricingDialog&&!pricingDialog.open){}else if(pricingDialog&&pricingDialog.open){renderPricingStatus();}});
-var dashboardRoute=readDashboardRoute();var publicPathPrefix=dashboardRoute.publicPathPrefix;var pluginID=dashboardRoute.pluginID;var resourceBase=publicPathPrefix+'/v0/resource/plugins/'+encodeURIComponent(pluginID);var managementBase=publicPathPrefix+'/v0/management/plugins/'+encodeURIComponent(pluginID);var statsURL=resourceBase+'/stats';var statsInitialURL=resourceBase+'/stats/initial';var statsTrendsURL=resourceBase+'/stats/trends';var statsGroupsURL=resourceBase+'/stats/groups';var requestsURL=resourceBase+'/requests';var costsURL=resourceBase+'/costs';var pricesURL=resourceBase+'/prices';var preferencesURL=resourceBase+'/preferences';var exchangeRateURL=resourceBase+'/exchange-rate';var modelsURL=publicPathPrefix+'/v1/models';var savePricesURL=managementBase+'/prices';var syncPricesURL=managementBase+'/prices/sync';var resetURL=managementBase+'/reset';var backupURL=managementBase+'/backup';var restoreURL=managementBase+'/restore';var refreshTimer=null,currentData=null,currentCosts=null,costQuery='',costLoadError='',selectedModel='',hiddenModels=new Set(),hiddenTrendSeries=new Set(),prices=Object.create(null),priceBookRevision=0,syncSettings={provider_priority:[],ignored_suffixes:[],mappings:[]},lastSync=null,cliModels=[],cliModelSet=Object.create(null),cliModelsLoadedAt=null,cliModelsPromise=null,pendingDeletedPrices=new Set(),manualDraftModels=new Set(),tokenDisplayMode='full',displayCurrency='USD',exchangeRate=null,exchangeRatePromise=null,moneyFormatters=Object.create(null),tokenTrendZoom={start:0,size:0},costTrendZoom={start:0,size:0},lastTrend=[],lastCostTrend=[],requestModelFilter='',requestSourceFilter='',requestResultFilter='',requestOffset=0,requestLimit=100,requestTotal=0,requestLoadSequence=0,currentRequestPage=null,requestSortKey='time',requestSortDirection='desc',hiddenRequestColumns=new Set(),dimensionOffset=0,dimensionLimit=100,dimensionTotal=0,currentDimensionGroups=[],dimensionSortKey='total_tokens',dimensionSortDirection='desc',hiddenDimensionColumns=new Set(),statsLoadSequence=0,preferencesSaveInFlight=false,preferencesSavePending=false,preferencesSaveDirty=false,chartResizeFrame=0;var palette=['#716dff','#3dbb91','#e89b49','#dd6f91','#47a7dc','#9b78e6','#70a84f','#d7b23f','#5bb9bd','#cc7662','#7e91a8','#b88755'];var tooltip=document.getElementById('tooltip'),resetDialog=document.getElementById('resetDialog'),resetKeyInput=document.getElementById('resetKeyInput'),backupDialog=document.getElementById('backupDialog'),backupKeyInput=document.getElementById('backupKeyInput'),pricingDialog=document.getElementById('pricingDialog'),cliModelsKeyInput=document.getElementById('cliModelsKeyInput'),manualModelInput=document.getElementById('manualModelInput'),pricingDialogAnimationToken=0,pricingDialogCloseTimer=null,pricingDialogRestoreFocus=false;
+var dashboardRoute=readDashboardRoute();var publicPathPrefix=dashboardRoute.publicPathPrefix;var pluginID=dashboardRoute.pluginID;var resourceBase=publicPathPrefix+'/v0/resource/plugins/'+encodeURIComponent(pluginID);var managementBase=publicPathPrefix+'/v0/management/plugins/'+encodeURIComponent(pluginID);var statsURL=resourceBase+'/stats';var statsInitialURL=resourceBase+'/stats/initial';var statsTrendsURL=resourceBase+'/stats/trends';var statsGroupsURL=resourceBase+'/stats/groups';var requestsURL=resourceBase+'/requests';var costsURL=resourceBase+'/costs';var pricesURL=resourceBase+'/prices';var preferencesURL=resourceBase+'/preferences';var exchangeRateURL=resourceBase+'/exchange-rate';var modelsURL=publicPathPrefix+'/v1/models';var savePricesURL=managementBase+'/prices';var syncPricesURL=managementBase+'/prices/sync';var resetURL=managementBase+'/reset';var backupURL=managementBase+'/backup';var restoreURL=managementBase+'/restore';var dashboardRangeResetAfter=15*60*1000,refreshTimer=null,currentData=null,currentCosts=null,costQuery='',costLoadError='',selectedModel='',hiddenModels=new Set(),hiddenTrendSeries=new Set(),prices=Object.create(null),priceBookRevision=0,syncSettings={provider_priority:[],ignored_suffixes:[],mappings:[]},lastSync=null,cliModels=[],cliModelSet=Object.create(null),cliModelsLoadedAt=null,cliModelsPromise=null,pendingDeletedPrices=new Set(),manualDraftModels=new Set(),tokenDisplayMode='full',lastDashboardOpenAt='',displayCurrency='USD',exchangeRate=null,exchangeRatePromise=null,moneyFormatters=Object.create(null),tokenTrendZoom={start:0,size:0},costTrendZoom={start:0,size:0},lastTrend=[],lastCostTrend=[],requestModelFilter='',requestSourceFilter='',requestResultFilter='',requestOffset=0,requestLimit=100,requestTotal=0,requestLoadSequence=0,currentRequestPage=null,requestSortKey='time',requestSortDirection='desc',hiddenRequestColumns=new Set(),dimensionOffset=0,dimensionLimit=100,dimensionTotal=0,currentDimensionGroups=[],dimensionSortKey='total_tokens',dimensionSortDirection='desc',hiddenDimensionColumns=new Set(),statsLoadSequence=0,preferencesSaveInFlight=false,preferencesSavePending=false,preferencesSaveDirty=false,chartResizeFrame=0;var palette=['#716dff','#3dbb91','#e89b49','#dd6f91','#47a7dc','#9b78e6','#70a84f','#d7b23f','#5bb9bd','#cc7662','#7e91a8','#b88755'];var tooltip=document.getElementById('tooltip'),resetDialog=document.getElementById('resetDialog'),resetKeyInput=document.getElementById('resetKeyInput'),backupDialog=document.getElementById('backupDialog'),backupKeyInput=document.getElementById('backupKeyInput'),pricingDialog=document.getElementById('pricingDialog'),cliModelsKeyInput=document.getElementById('cliModelsKeyInput'),manualModelInput=document.getElementById('manualModelInput'),pricingDialogAnimationToken=0,pricingDialogCloseTimer=null,pricingDialogRestoreFocus=false;
 var selectedSource='',modelShareMetric='requests';
 var appliedRangeMode='custom',appliedRangeStart=null,appliedRangeEnd=null,draftRangeMode=null,draftRangeStart=null,draftRangeEnd=null,calendarBaseMonth=null,dateRangeAnimationToken=0,dateRangeCloseTimer=null,dateRangeRestoreFocus=false,calendarShiftToken=0,calendarShiftTimer=null,activeTimePicker=null;var dateRangePopover=document.getElementById('dateRangePopover'),rangeButton=document.getElementById('rangeButton');
 function readDashboardRoute(){var path=window.location.pathname,marker='/v0/resource/plugins/',index=path.lastIndexOf(marker);if(index<0)return {publicPathPrefix:'',pluginID:''};var encodedID=path.slice(index+marker.length).split('/')[0];if(!encodedID)return {publicPathPrefix:'',pluginID:''};try{return {publicPathPrefix:path.slice(0,index),pluginID:decodeURIComponent(encodedID)};}catch(_error){return {publicPathPrefix:path.slice(0,index),pluginID:encodedID};}}
@@ -420,12 +420,14 @@ function openFullModeDialog(){fullModeKeyInput.value='';text('fullModeError','')
 function exitFullMode(){if(!fullModePage)return;if(pricingDialog&&pricingDialog.open)closePricingDialog(false);fullModeSession='';window.location.assign(resourceBase+'/dashboard');}
 function handleFullModeButton(){if(fullModePage){exitFullMode();return;}openFullModeDialog();}
 async function unlockFullMode(){var key=fullModeKeyInput.value.trim();if(!key){text('fullModeError',t('fullMode.keyRequired'));fullModeKeyInput.focus();return;}var button=document.getElementById('fullModeUnlockButton');button.disabled=true;text('fullModeError','');try{var result=await api(managementBase+'/full-mode/session',{method:'POST',headers:{'Authorization':'Bearer '+key}}),session=String(result.session||'');fullModeKeyInput.value='';if(!session)throw new Error(t('error.api',{status:500}));window.location.assign(resourceBase+'/full-dashboard#session='+encodeURIComponent(session));}catch(error){fullModeKeyInput.value='';text('fullModeError',error.message);fullModeKeyInput.focus();}finally{button.disabled=false;}}
-function dashboardPreferencesPayload(){return {request_page_size:requestLimit,dimension_page_size:dimensionLimit,hidden_request_columns:Array.from(hiddenRequestColumns),hidden_dimension_columns:Array.from(hiddenDimensionColumns),time_range_mode:appliedRangeMode,token_display_mode:tokenDisplayMode,time_range_start:appliedRangeMode==='custom'?appliedRangeStart.toISOString():'',time_range_end:appliedRangeMode==='custom'?appliedRangeEnd.toISOString():''};}
+function dashboardPreferencesPayload(){return {request_page_size:requestLimit,dimension_page_size:dimensionLimit,hidden_request_columns:Array.from(hiddenRequestColumns),hidden_dimension_columns:Array.from(hiddenDimensionColumns),time_range_mode:appliedRangeMode,token_display_mode:tokenDisplayMode,time_range_start:appliedRangeMode==='custom'?appliedRangeStart.toISOString():'',time_range_end:appliedRangeMode==='custom'?appliedRangeEnd.toISOString():'',last_dashboard_open_at:lastDashboardOpenAt};}
 function validHiddenColumns(values,columns){var allowed=new Set(columns.map(function(column){return column.key;})),result=[];(Array.isArray(values)?values:[]).forEach(function(key){if(allowed.has(key)&&result.indexOf(key)<0)result.push(key);});return result.length<columns.length?result:result.slice(0,Math.max(0,columns.length-1));}
 function parseLocalDate(value){var match=String(value||'').match(/^(\d{4})-(\d{2})-(\d{2})$/);if(!match)return null;var date=new Date(Number(match[1]),Number(match[2])-1,Number(match[3]));return dateKey(date)===value?date:null;}
 function parseSavedRange(value){var legacy=parseLocalDate(value);if(legacy)return {date:legacy,legacy:true};var timestamp=new Date(value);return Number.isNaN(timestamp.getTime())?null:{date:timestamp,legacy:false};}
-function applyDashboardPreferences(value){value=value||{};requestLimit=Math.max(1,Math.min(500,Math.floor(Number(value.request_page_size)||100)));dimensionLimit=Math.max(1,Math.min(500,Math.floor(Number(value.dimension_page_size)||100)));hiddenRequestColumns=new Set(validHiddenColumns(value.hidden_request_columns,requestColumns));hiddenDimensionColumns=new Set(validHiddenColumns(value.hidden_dimension_columns,dimensionColumns));var tokenDisplayModes={full:true,k:true,m:true,B:true};tokenDisplayMode=tokenDisplayModes[value.token_display_mode]?value.token_display_mode:'full';var modes={custom:true,last_5_hours:true,last_7_days:true,last_30_days:true,current_month:true},mode=modes[value.time_range_mode]?value.time_range_mode:'custom',start=parseSavedRange(value.time_range_start),end=parseSavedRange(value.time_range_end);appliedRangeMode=mode;if(mode==='custom'&&start&&end&&start.legacy===end.legacy){var startValue=start.date,endValue=end.legacy?new Date(end.date.getFullYear(),end.date.getMonth(),end.date.getDate()+1):end.date;if(startValue.getTime()<endValue.getTime()){appliedRangeStart=startValue;appliedRangeEnd=endValue;}}else if(mode!=='custom'){var resolved=resolvedDateRange();appliedRangeStart=new Date(resolved.start);appliedRangeEnd=new Date(resolved.end);}document.getElementById('requestPageSize').value=String(requestLimit);document.getElementById('dimensionPageSize').value=String(dimensionLimit);updateTokenUnitButton();updateRangeButton();updateGranularityForRange();}async function loadDashboardPreferences(){applyDashboardPreferences(await api(preferencesURL));}
-function dashboardPreferencesSaveURL(){var value=dashboardPreferencesPayload(),params=new URLSearchParams();params.set('save','1');params.set('request_page_size',String(value.request_page_size));params.set('dimension_page_size',String(value.dimension_page_size));params.set('time_range_mode',value.time_range_mode);params.set('token_display_mode',value.token_display_mode);if(value.time_range_start)params.set('time_range_start',value.time_range_start);if(value.time_range_end)params.set('time_range_end',value.time_range_end);value.hidden_request_columns.forEach(function(key){params.append('hidden_request_column',key);});value.hidden_dimension_columns.forEach(function(key){params.append('hidden_dimension_column',key);});return preferencesURL+'?'+params.toString();}
+function setAppliedTodayRange(){var today=localDateOnly(new Date());appliedRangeMode='custom';appliedRangeStart=today;appliedRangeEnd=new Date(today.getFullYear(),today.getMonth(),today.getDate()+1);resetTrendZooms();updateRangeButton();updateGranularityForRange();}
+function markDashboardOpened(){var now=new Date(),previous=new Date(lastDashboardOpenAt),hasPrevious=lastDashboardOpenAt&&Number.isFinite(previous.getTime());if(hasPrevious&&now.getTime()-previous.getTime()>=dashboardRangeResetAfter)setAppliedTodayRange();lastDashboardOpenAt=now.toISOString();scheduleDashboardPreferencesSave();}
+function applyDashboardPreferences(value){value=value||{};requestLimit=Math.max(1,Math.min(500,Math.floor(Number(value.request_page_size)||100)));dimensionLimit=Math.max(1,Math.min(500,Math.floor(Number(value.dimension_page_size)||100)));hiddenRequestColumns=new Set(validHiddenColumns(value.hidden_request_columns,requestColumns));hiddenDimensionColumns=new Set(validHiddenColumns(value.hidden_dimension_columns,dimensionColumns));var tokenDisplayModes={full:true,k:true,m:true,B:true};tokenDisplayMode=tokenDisplayModes[value.token_display_mode]?value.token_display_mode:'full';lastDashboardOpenAt=typeof value.last_dashboard_open_at==='string'?value.last_dashboard_open_at:'';var modes={custom:true,last_5_hours:true,last_7_days:true,last_30_days:true,current_month:true},mode=modes[value.time_range_mode]?value.time_range_mode:'custom',start=parseSavedRange(value.time_range_start),end=parseSavedRange(value.time_range_end);appliedRangeMode=mode;if(mode==='custom'&&start&&end&&start.legacy===end.legacy){var startValue=start.date,endValue=end.legacy?new Date(end.date.getFullYear(),end.date.getMonth(),end.date.getDate()+1):end.date;if(startValue.getTime()<endValue.getTime()){appliedRangeStart=startValue;appliedRangeEnd=endValue;}}else if(mode!=='custom'){var resolved=resolvedDateRange();appliedRangeStart=new Date(resolved.start);appliedRangeEnd=new Date(resolved.end);}document.getElementById('requestPageSize').value=String(requestLimit);document.getElementById('dimensionPageSize').value=String(dimensionLimit);updateTokenUnitButton();updateRangeButton();updateGranularityForRange();}async function loadDashboardPreferences(){applyDashboardPreferences(await api(preferencesURL));markDashboardOpened();}
+function dashboardPreferencesSaveURL(){var value=dashboardPreferencesPayload(),params=new URLSearchParams();params.set('save','1');params.set('request_page_size',String(value.request_page_size));params.set('dimension_page_size',String(value.dimension_page_size));params.set('time_range_mode',value.time_range_mode);params.set('token_display_mode',value.token_display_mode);if(value.time_range_start)params.set('time_range_start',value.time_range_start);if(value.time_range_end)params.set('time_range_end',value.time_range_end);if(value.last_dashboard_open_at)params.set('last_dashboard_open_at',value.last_dashboard_open_at);value.hidden_request_columns.forEach(function(key){params.append('hidden_request_column',key);});value.hidden_dimension_columns.forEach(function(key){params.append('hidden_dimension_column',key);});return preferencesURL+'?'+params.toString();}
 async function saveDashboardPreferences(){return api(dashboardPreferencesSaveURL(),{keepalive:true});}
 function flushDashboardPreferencesSave(){if(preferencesSaveInFlight||!preferencesSavePending)return;preferencesSavePending=false;preferencesSaveInFlight=true;saveDashboardPreferences().then(function(){if(!preferencesSavePending)preferencesSaveDirty=false;}).catch(function(error){text('error',error.message);}).finally(function(){preferencesSaveInFlight=false;if(preferencesSavePending)flushDashboardPreferencesSave();});}
 function scheduleDashboardPreferencesSave(){preferencesSaveDirty=true;preferencesSavePending=true;flushDashboardPreferencesSave();}
@@ -438,7 +440,7 @@ function groupModels(groups){var map=Object.create(null);groups.forEach(function
 function modelRows(){if(!currentData)return [];return Array.isArray(currentData.models)?currentData.models:(currentData.groups||[]);}
 function visibleGroups(){return modelRows().filter(function(group){var name=modelName(group.model);return !hiddenModels.has(name)&&(!selectedModel||name===selectedModel);});}
 function cleanRate(value){value=Number(value||0);return Number.isFinite(value)&&value>=0?value:0;}
-function applyPrices(values){prices=Object.create(null);Object.keys(values||{}).forEach(function(name){var value=values[name]||{},tiers=Array.isArray(value.context_tiers)?value.context_tiers.map(function(tier){return {threshold:Math.max(0,Math.floor(Number(tier.threshold||0))),input:cleanRate(tier.input),output:cleanRate(tier.output),cache_read:cleanRate(tier.cache_read),cache_creation:cleanRate(tier.cache_creation)};}):[];prices[name]={input:cleanRate(value.input),output:cleanRate(value.output),cache_read:cleanRate(value.cache_read),cache_creation:cleanRate(value.cache_creation),context_tiers:tiers,service_tiers:value.service_tiers||{},accounting_mode:value.accounting_mode||'',source:value.source||'',catalog_provider:value.catalog_provider||'',catalog_model:value.catalog_model||'',updated_at:value.updated_at||''};});}
+function applyPrices(values){prices=Object.create(null);Object.keys(values||{}).forEach(function(name){var value=values[name]||{},tiers=Array.isArray(value.context_tiers)?value.context_tiers.map(function(tier){return {threshold:Math.max(0,Math.floor(Number(tier.threshold||0))),input:cleanRate(tier.input),output:cleanRate(tier.output),cache_read:cleanRate(tier.cache_read),cache_creation:cleanRate(tier.cache_creation)};}):[];prices[name]={input:cleanRate(value.input),output:cleanRate(value.output),cache_read:cleanRate(value.cache_read),cache_creation:cleanRate(value.cache_creation),context_tiers:tiers,time_zone:value.time_zone||'',time_tiers:Array.isArray(value.time_tiers)?value.time_tiers.map(function(tier){return {name:tier.name||'',days:Array.isArray(tier.days)?tier.days.slice():[],start:tier.start||'',end:tier.end||'',input:cleanRate(tier.input),output:cleanRate(tier.output),cache_read:cleanRate(tier.cache_read),cache_creation:cleanRate(tier.cache_creation)};}):[],service_tiers:value.service_tiers||{},accounting_mode:value.accounting_mode||'',source:value.source||'',catalog_provider:value.catalog_provider||'',catalog_model:value.catalog_model||'',updated_at:value.updated_at||''};});}
 function applyPriceBook(book){book=book||{};applyPrices(book.prices);priceBookRevision=Number(book.revision||0);syncSettings=book.sync_settings||{provider_priority:[],ignored_suffixes:[],mappings:[]};lastSync=book.last_sync||null;}
 function priceFor(name){return prices[name]||{input:0,output:0,cache_read:0,cache_creation:0,context_tiers:[],service_tiers:{},accounting_mode:'',source:'',catalog_provider:'',catalog_model:'',updated_at:''};}
 function sumCostInto(target,item){['requests','priced_requests','unpriced_requests','input_usd','output_usd','cache_read_usd','cache_creation_usd','total_usd'].forEach(function(key){target[key]=(target[key]||0)+Number(item&&item[key]||0);});return target;}
@@ -452,7 +454,7 @@ function modelShareDetail(item){var cost=exactModelCost(item.model);if(modelShar
 function syncModelShareMetricButtons(){if(modelShareMetric==='cost'&&!currentCosts)modelShareMetric='requests';document.querySelectorAll('[data-model-share-metric]').forEach(function(button){var metric=button.getAttribute('data-model-share-metric'),unavailable=metric==='cost'&&!currentCosts;button.disabled=unavailable;button.setAttribute('aria-pressed',String(metric===modelShareMetric));button.title=unavailable?t('modelShare.costUnavailable'):'';});}
 function setModelShareMetric(metric){if(metric!=='requests'&&metric!=='tokens'&&metric!=='cost'||metric==='cost'&&!currentCosts||metric===modelShareMetric)return;modelShareMetric=metric;renderDonut();}
 function coverageText(summary){if(!summary)return t('pricing.coverageWaiting');var total=Number(summary.requests||0),priced=Number(summary.priced_requests||0),unpriced=Number(summary.unpriced_requests||0);return t('pricing.coverage',{priced:fmt(priced),total:fmt(total),unpriced:fmt(unpriced)});}
-function costBreakdownTitle(cost){if(!cost||!cost.priced)return t('pricing.noCost');return t('pricing.costBreakdown',{input:money(cost.input_usd),output:money(cost.output_usd),cacheRead:money(cost.cache_read_usd),cacheCreation:money(cost.cache_creation_usd),mode:cost.accounting_mode||t('locale.unavailable'),tier:cost.tier_threshold?fmt(cost.tier_threshold):t('value.base')});}
+function costBreakdownTitle(cost){if(!cost||!cost.priced)return t('pricing.noCost');return t('pricing.costBreakdown',{input:money(cost.input_usd),output:money(cost.output_usd),cacheRead:money(cost.cache_read_usd),cacheCreation:money(cost.cache_creation_usd),mode:cost.accounting_mode||t('locale.unavailable'),tier:cost.tier_threshold?fmt(cost.tier_threshold):t('value.base')})+(cost.price_time_tier?' · '+t('pricing.timeTitle')+': '+cost.price_time_tier+' ('+cost.price_time_zone+')':'');}
 function render(data,costs){currentData=data;currentCosts=costs;/*FULL_MODE_APIKEY_RENDER*/var available=new Set(groupModels(modelRows()).map(function(item){return item.model;}));if(selectedModel&&!available.has(selectedModel)){if(requestModelFilter===selectedModel)requestModelFilter='';selectedModel='';}hiddenModels.forEach(function(name){if(!available.has(name))hiddenModels.delete(name);});var costStatus=costs?' · '+coverageText(costs.summary)+' · '+t('status.priceBook',{revision:Number(costs.price_book_revision||0)}):' · '+t('status.costUnavailable');text('status',t('status.range',{range:dateRangeLabel(appliedRangeStart,appliedRangeEnd)})+' · '+t('status.recentActivity',{value:data.last_used&&data.last_used.indexOf('0001-')!==0?localeDate(new Date(data.last_used)):t('locale.unavailable')})+costStatus+' · '+t('status.updated',{value:new Date(data.generated_at).toLocaleTimeString(formatterLocale)}));if(costLoadError)text('error',t('error.costUnavailable',{message:costLoadError}));renderRequestFilters();renderVisuals();}
 function renderVisuals(){if(!currentData)return;var groups=visibleGroups(),summary={};groups.forEach(function(group){sumInto(summary,group);});var models=groupModels(groups),top=models.slice().sort(function(a,b){return b.requests-a.requests||b.total_tokens-a.total_tokens;})[0],costSummary=visibleCostSummary(),currencyStatus=displayCurrency==='CNY'&&exchangeRate?t('currency.rate',{rate:Number(exchangeRate.rate).toFixed(4)})+(exchangeRate.stale?t('currency.stale'):'')+' · '+localeDate(new Date(exchangeRate.effective_at||exchangeRate.fetched_at)):'';animateText('totalTokens',formatTokenTotal(summary.total_tokens));animateText('totalCost',costSummary?money(costSummary.total_usd):t('value.unavailable'));text('costCoverage',(costSummary?coverageText(costSummary):(costLoadError?t('status.costUnavailable'):t('status.costUnavailable')))+currencyStatus);animateText('requests',fmt(summary.requests));animateText('topModel',top?top.model:t('locale.unavailable'));text('modelBadge',top?top.model.slice(0,2).toUpperCase():'AI');text('tokenDetail',t('card.tokenDetailValues',{inputLabel:t('card.input'),input:formatTokenTotal(summary.input_tokens),outputLabel:t('card.output'),output:formatTokenTotal(summary.output_tokens),cacheReadLabel:t('card.cacheRead'),cacheRead:formatTokenTotal(summary.cache_read_tokens)}));var success=Number(summary.requests||0)?((Number(summary.requests)-Number(summary.failed_requests||0))/Number(summary.requests)*100):0;text('requestDetail',t('card.successRate',{value:success.toFixed(1)}));text('topModelDetail',top?t('model.calls',{count:fmt(top.requests)})+' · '+t('model.tokens',{count:formatTokenTotal(top.total_tokens)}):t('card.byRequests'));text('trendSubtitle',selectedModel?t('trend.selected',{model:selectedModel}):t('trend.subtitle'));text('tableSubtitle',selectedModel?t('table.dimensions.subtitle')+' · '+selectedModel:t('table.dimensions.subtitle'));text('requestTableSubtitle',t('table.requests.subtitle')+(currentCosts?' · '+t('status.priceBook',{revision:Number(currentCosts.price_book_revision||0)}):' · '+t('status.costUnavailable')));document.getElementById('resetModelButton').hidden=!selectedModel;renderGroups(currentDimensionGroups,dimensionTotal);renderBar();renderDonut();renderCostTrend();renderEfficiency();}
 function cell(row,value,cls){var td=document.createElement('td');td.textContent=value===undefined||value===null||value===''?'—':String(value);if(cls)td.className=cls;row.appendChild(td);return td;}
@@ -584,6 +586,10 @@ function showModelTooltip(event,item,percent){var exact=exactModelCost(item.mode
 function selectModel(name,options){selectedModel=selectedModel===name?'':name;requestModelFilter=selectedModel;if(selectedModel)hiddenModels.delete(selectedModel);resetTrendZooms();dimensionOffset=0;renderRequestFilters();renderVisuals();if(currentData)loadGroups(statsLoadSequence,dateRangeQuery()).catch(function(error){text('error',error.message);});refreshRequestDetails();if(options&&options.restoreDonutFocus){var segments=document.querySelectorAll('#donut .donut-segment');for(var i=0;i<segments.length;i++){if(segments[i].getAttribute('data-model')===name){segments[i].focus();break;}}}}
 function toggleModel(name){if(hiddenModels.has(name))hiddenModels.delete(name);else hiddenModels.add(name);var changedSelection=selectedModel===name;if(changedSelection)selectedModel='';resetTrendZooms();dimensionOffset=0;renderVisuals();if(currentData)loadGroups(statsLoadSequence,dateRangeQuery()).catch(function(error){text('error',error.message);});if(changedSelection)refreshRequestDetails();}
 function priceNumberInput(className,value,label){var input=document.createElement('input');input.type='number';input.min='0';input.max='1000000';input.step='0.01';input.className=className;input.value=String(cleanRate(value));input.setAttribute('aria-label',label);return input;}
+function timeField(parent,cls,label,value,type){var wrap=document.createElement('label'),input=document.createElement('input');wrap.textContent=label;input.className=cls;input.type=type||'text';input.value=value||'';input.setAttribute('aria-label',label);wrap.appendChild(input);parent.appendChild(wrap);return input;}
+function makeTimeTier(tier){var row=document.createElement('div');row.className='time-tier-row';timeField(row,'time-name',t('pricing.timeName'),tier.name);timeField(row,'time-days',t('pricing.timeDays'),(tier.days||[]).join(','));timeField(row,'time-start',t('pricing.timeStart'),tier.start||'23:00','time');timeField(row,'time-end',t('pricing.timeEnd'),tier.end||'08:00','time');[['input','Input'],['output','Output'],['cache_read','Cache Read'],['cache_creation','Cache Creation']].forEach(function(pair){var label=document.createElement('label');label.textContent=pair[1];label.appendChild(priceNumberInput('time-'+pair[0],tier[pair[0]],pair[1]));row.appendChild(label);});var remove=document.createElement('button');remove.type='button';remove.className='mini-button';remove.textContent=t('button.remove');remove.onclick=function(){row.remove();};row.appendChild(remove);return row;}
+function makeTimePricing(price){var panel=document.createElement('details');panel.className='time-pricing';var summary=document.createElement('summary');summary.textContent=t('pricing.timeTitle');panel.appendChild(summary);var help=document.createElement('p');help.textContent=t('pricing.timeHelp');panel.appendChild(help);timeField(panel,'time-zone',t('pricing.timeZone'),price.time_zone||'UTC');var rows=document.createElement('div');rows.className='time-tier-list';(price.time_tiers||[]).forEach(function(tier){rows.appendChild(makeTimeTier(tier));});panel.appendChild(rows);var add=document.createElement('button');add.type='button';add.className='mini-button add-time-tier';add.textContent=t('pricing.timeAdd');add.onclick=function(){rows.appendChild(makeTimeTier({name:'',input:price.input,output:price.output,cache_read:price.cache_read,cache_creation:price.cache_creation}));};panel.appendChild(add);return panel;}
+function collectTimePricing(row){var zone=row.querySelector('.time-zone').value.trim()||'UTC',tiers=[],occupied=new Set(),names=new Set();try{if(zone==='Local')throw new Error();new Intl.DateTimeFormat('en',{timeZone:zone});}catch(e){throw new Error(t('pricing.timeInvalid'));}row.querySelectorAll('.time-tier-row').forEach(function(r){var name=r.querySelector('.time-name').value.trim(),raw=r.querySelector('.time-days').value.trim(),days=raw?raw.split(',').map(function(d){return Number(d.trim());}):[],start=r.querySelector('.time-start').value,end=r.querySelector('.time-end').value;function minute(v){if(!/^\d{2}:\d{2}$/.test(v))return NaN;var a=v.split(':').map(Number);return a[0]<24&&a[1]<60?a[0]*60+a[1]:NaN;}var a=minute(start),b=minute(end);if(!name||names.has(name)||!Number.isFinite(a)||!Number.isFinite(b)||a===b||days.some(function(d){return !Number.isInteger(d)||d<1||d>7;})||new Set(days).size!==days.length)throw new Error(t('pricing.timeInvalid'));names.add(name);(days.length?days:[1,2,3,4,5,6,7]).forEach(function(day){for(var n=0;n<(b-a+1440)%1440;n++){var key=((day-1)*1440+a+n)%10080;if(occupied.has(key))throw new Error(t('pricing.timeOverlap'));occupied.add(key);}});var tier={name:name,days:days,start:start,end:end};['input','output','cache_read','cache_creation'].forEach(function(k){var v=Number(r.querySelector('.time-'+k).value);if(!Number.isFinite(v)||v<0||v>1000000)throw new Error(t('error.invalidPrice'));tier[k]=v;});tiers.push(tier);});if(tiers.length>32)throw new Error(t('pricing.timeInvalid'));return {time_zone:zone,time_tiers:tiers};}
 function makeTierRow(name,tier){var row=document.createElement('div');row.className='price-tier-row context-tier-row';var threshold=document.createElement('input');threshold.type='number';threshold.min='1';threshold.max='9007199254740991';threshold.step='1';threshold.className='tier-threshold';threshold.value=String(Math.max(1,Math.floor(Number(tier.threshold||1))));threshold.setAttribute('aria-label',name+' Context Tier threshold');row.appendChild(threshold);row.appendChild(priceNumberInput('tier-input',tier.input,name+' Context Tier Input'));row.appendChild(priceNumberInput('tier-output',tier.output,name+' Context Tier Output'));row.appendChild(priceNumberInput('tier-cache-read',tier.cache_read,name+' Context Tier Cache Read'));row.appendChild(priceNumberInput('tier-cache-creation',tier.cache_creation,name+' Context Tier Cache Creation'));var remove=document.createElement('button');remove.type='button';remove.className='mini-button remove-context-tier';remove.textContent=t('button.remove');remove.addEventListener('click',function(){row.remove();});row.appendChild(remove);return row;}
 function normalizeCLIModels(payload){if(!payload||!Array.isArray(payload.data))throw new Error(t('error.invalidModelsResponse'));var seen=Object.create(null),models=[];payload.data.forEach(function(item){var id=item&&typeof item.id==='string'?item.id.trim():'';if(!id)return;if(id.length>256)throw new Error(t('error.longModelName'));if(!seen[id]){seen[id]=true;models.push(id);if(models.length>10000)throw new Error(t('error.tooManyModels'));}});models.sort(function(a,b){return a.localeCompare(b);});if(!models.length)throw new Error(t('error.noModels'));return models;}
 async function fetchCLIModels(renderEditor){var apiKey=cliModelsKeyInput.value.trim();if(!apiKey){text('priceError',t('error.missingAPIKey'));cliModelsKeyInput.focus();throw new Error(t('error.missingKey'));}text('priceError','');if(!cliModelsPromise){text('modelCatalogStatus',t('pricing.catalogLoading'));cliModelsPromise=api(modelsURL,{headers:{'Authorization':'Bearer '+apiKey}}).then(function(payload){cliModels=normalizeCLIModels(payload);cliModelSet=Object.create(null);cliModels.forEach(function(name){cliModelSet[name]=true;});cliModelsLoadedAt=new Date();text('modelCatalogStatus',t('pricing.catalogLoaded',{count:fmt(cliModels.length),time:cliModelsLoadedAt.toLocaleTimeString(formatterLocale)}));return cliModels.slice();}).finally(function(){cliModelsPromise=null;});}try{var models=await cliModelsPromise;if(renderEditor)renderPricingEditor();return models.slice();}catch(error){text('modelCatalogStatus',t('pricing.catalogFailed'));text('priceError',error.message);throw error;}}
@@ -594,17 +600,17 @@ function syncListText(values){return (values||[]).join('\n');}
 function syncMappingText(values){return (values||[]).map(function(item){return String(item.source||'')+'='+String(item.target||'');}).join('\n');}
 function renderPricingStatus(){text('priceRevision',t('pricing.revision',{revision:priceBookRevision}));text('priceCoverageStatus',currentCosts?coverageText(currentCosts.summary):t('pricing.coverageWaiting'));var missing=(currentCosts&&currentCosts.missing_prices)||[];text('missingPriceStatus',missing.length?t('pricing.missing',{value:missing.slice(0,8).map(function(item){return (item.provider?item.provider+'/':'')+modelName(item.model)+' ('+fmt(item.requests)+')';}).join('、')+(missing.length>8?' +'+missing.length:'') }):t('pricing.missingNone'));text('pendingDeleteStatus',pendingDeletedPrices.size?t('pricing.pendingDeleteSaved',{count:fmt(pendingDeletedPrices.size)}):t('pricing.pendingDelete',{count:0}));if(lastSync){var completed=lastSync.completed_at?localeDate(new Date(lastSync.completed_at)):t('locale.unavailable'),pending=Math.max(0,Number(lastSync.observed||0)-Number(lastSync.matched||0)-Number(lastSync.unmatched||0)),retained=lastSync.skipped_manual?t('pricing.syncRetained',{count:fmt(lastSync.skipped_manual)}):'';text('lastSyncStatus',t('pricing.syncSummary',{time:completed,observed:fmt(lastSync.observed),pending:fmt(pending),matched:fmt(lastSync.matched),unmatched:fmt(lastSync.unmatched),created:fmt(lastSync.created),updated:fmt(lastSync.updated),retained:retained}));}else{text('lastSyncStatus',t('pricing.lastSync'));}}
 function capturePricingEditor(){var snapshot=Object.create(null);document.querySelectorAll('#priceList>.price-row').forEach(function(row){var tiers=[];row.querySelectorAll('.context-tier-row').forEach(function(tierRow){tiers.push({threshold:tierRow.querySelector('.tier-threshold').value,input:tierRow.querySelector('.tier-input').value,output:tierRow.querySelector('.tier-output').value,cache_read:tierRow.querySelector('.tier-cache-read').value,cache_creation:tierRow.querySelector('.tier-cache-creation').value});});snapshot[row.dataset.model]={input:row.querySelector('.price-input').value,output:row.querySelector('.price-output').value,cache_read:row.querySelector('.price-cache-read').value,cache_creation:row.querySelector('.price-cache-creation').value,accounting_mode:row.querySelector('.price-accounting-mode').value,context_tiers:tiers,tiers_hidden:row.querySelector('.price-tiers').hidden};});return snapshot;}function restorePricingEditor(snapshot){document.querySelectorAll('#priceList>.price-row').forEach(function(row){var name=row.dataset.model,value=snapshot[name];if(!value)return;row.querySelector('.price-input').value=value.input;row.querySelector('.price-output').value=value.output;row.querySelector('.price-cache-read').value=value.cache_read;row.querySelector('.price-cache-creation').value=value.cache_creation;row.querySelector('.price-accounting-mode').value=value.accounting_mode;var tiers=row.querySelector('.price-tiers'),meta=tiers.querySelector('.price-meta-row');tiers.querySelectorAll('.context-tier-row').forEach(function(tierRow){tierRow.remove();});value.context_tiers.forEach(function(tier){var tierRow=makeTierRow(name,tier);tierRow.querySelector('.tier-threshold').value=tier.threshold;tierRow.querySelector('.tier-input').value=tier.input;tierRow.querySelector('.tier-output').value=tier.output;tierRow.querySelector('.tier-cache-read').value=tier.cache_read;tierRow.querySelector('.tier-cache-creation').value=tier.cache_creation;tiers.insertBefore(tierRow,meta);});tiers.hidden=value.tiers_hidden;var toggle=row.querySelector('.price-tier-toggle'),count=value.context_tiers.length;toggle.textContent=value.tiers_hidden?t('pricing.tierCount',{count:count}):t('button.collapseTiers')+' '+t('pricing.tierCount',{count:count});if(pendingDeletedPrices.has(name))setPriceDeletedState(row,true);});}function rerenderPricingEditor(excludedName){var snapshot=capturePricingEditor();if(excludedName)delete snapshot[excludedName];renderPricingEditor();restorePricingEditor(snapshot);}function focusPriceRow(name){var rows=document.querySelectorAll('#priceList>.price-row');for(var index=0;index<rows.length;index++){if(rows[index].dataset.model===name){var input=rows[index].querySelector('.price-input');if(input)input.focus();return;}}}function addManualModel(){var name=manualModelInput.value.trim();text('priceError','');if(!name){text('priceError',t('error.missingManualModel'));manualModelInput.focus();return;}if(Array.from(name).length>160){text('priceError',t('error.longManualModel'));manualModelInput.focus();return;}if(pendingDeletedPrices.has(name)){pendingDeletedPrices.delete(name);manualModelInput.value='';rerenderPricingEditor();focusPriceRow(name);return;}if(Object.prototype.hasOwnProperty.call(prices,name)||manualDraftModels.has(name)){text('priceError',t('error.duplicateManualModel',{model:name}));manualModelInput.focus();return;}if(Object.keys(prices).length-pendingDeletedPrices.size+manualDraftModels.size>=10000){text('priceError',t('error.tooManyManualModels'));manualModelInput.focus();return;}manualDraftModels.add(name);manualModelInput.value='';rerenderPricingEditor();focusPriceRow(name);}function setPriceDeletedState(row,deleted){var name=row.dataset.model,button=row.querySelector('.remove-model-price');row.classList.toggle('pending-delete',deleted);row.querySelectorAll('input,select,.price-tier-toggle,.add-context-tier,.remove-context-tier').forEach(function(control){control.disabled=deleted;});if(button){button.textContent=deleted?'撤销删除':'删除价格';if(locale!=='zh-CN'&&locale!=='zh-TW')button.textContent=deleted?t('button.undoDelete'):t('button.deletePrice');button.setAttribute('aria-pressed',String(deleted));}if(deleted)pendingDeletedPrices.add(name);else pendingDeletedPrices.delete(name);renderPricingStatus();}
-function renderPricingEditor(){var list=document.getElementById('priceList'),fragment=document.createDocumentFragment(),head=document.createElement('div');head.className='price-head';[t('pricing.model'),'Input','Output','Cache Read','Cache Creation',t('pricing.provenance')].forEach(function(value){var span=document.createElement('span');span.textContent=value;head.appendChild(span);});fragment.appendChild(head);var names=pricingNames();if(!names.length){var empty=document.createElement('div');empty.className='legend-empty';empty.textContent=cliModelsLoadedAt?t('pricing.noModels'):t('pricing.loadModelsHint');fragment.appendChild(empty);}names.forEach(function(name){var price=priceFor(name),row=document.createElement('div');row.className='price-row';row.dataset.model=name;var label=document.createElement('div');label.className='price-model';label.textContent=name;row.appendChild(label);row.appendChild(priceNumberInput('price-input',price.input,name+' Input'));row.appendChild(priceNumberInput('price-output',price.output,name+' Output'));row.appendChild(priceNumberInput('price-cache-read',price.cache_read,name+' Cache Read'));row.appendChild(priceNumberInput('price-cache-creation',price.cache_creation,name+' Cache Creation'));var provenance=document.createElement('div');provenance.className='price-provenance';var source=document.createElement('strong');source.textContent=price.source||(manualDraftModels.has(name)?t('pricing.manualDraftSource'):t('pricing.sourceUnset'));provenance.appendChild(source);var catalog=document.createElement('span');catalog.textContent=price.catalog_provider||price.catalog_model?t('pricing.catalogSource',{provider:price.catalog_provider||t('locale.unavailable'),model:price.catalog_model||t('locale.unavailable')}):t('pricing.manualSource');if(cliModelsLoadedAt&&!cliModelSet[name])catalog.textContent+=t('pricing.notInCatalog');provenance.appendChild(catalog);var hasSavedPrice=Object.prototype.hasOwnProperty.call(prices,name),isManualDraft=manualDraftModels.has(name);if(hasSavedPrice||isManualDraft){var removePrice=document.createElement('button');removePrice.type='button';removePrice.className='mini-button '+(hasSavedPrice?'remove-model-price':'remove-manual-model');removePrice.textContent=hasSavedPrice?t('button.deletePrice'):t('button.remove');removePrice.addEventListener('click',function(){if(hasSavedPrice){setPriceDeletedState(row,!pendingDeletedPrices.has(name));return;}manualDraftModels.delete(name);rerenderPricingEditor(name);manualModelInput.focus();});provenance.appendChild(removePrice);}row.appendChild(provenance);var toggle=document.createElement('button');toggle.type='button';toggle.className='mini-button price-tier-toggle';toggle.textContent=t('pricing.tierCount',{count:(price.context_tiers||[]).length});row.appendChild(toggle);var tiers=document.createElement('div');tiers.className='price-tiers context-tier-controls';tiers.hidden=true;var labels=document.createElement('div');labels.className='price-tier-row price-tier-labels';[t('pricing.threshold'),'Input','Output','Cache Read','Cache Creation',t('pricing.operation')].forEach(function(value){var span=document.createElement('span');span.textContent=value;labels.appendChild(span);});tiers.appendChild(labels);(price.context_tiers||[]).forEach(function(tier){tiers.appendChild(makeTierRow(name,tier));});var meta=document.createElement('div');meta.className='price-meta-row';var modeLabel=document.createElement('label');var modeText=document.createElement('span');modeText.textContent=t('pricing.accountingMode');var mode=document.createElement('select');mode.className='price-accounting-mode';[['',t('pricing.default')],['input_excludes_cache',t('pricing.inputExcludesCache')],['input_includes_cache',t('pricing.inputIncludesCache')]].forEach(function(optionValue){var option=document.createElement('option');option.value=optionValue[0];option.textContent=optionValue[1];if(price.accounting_mode===optionValue[0])option.selected=true;mode.appendChild(option);});modeLabel.appendChild(modeText);modeLabel.appendChild(mode);meta.appendChild(modeLabel);var add=document.createElement('button');add.type='button';add.className='mini-button add-context-tier';add.textContent=t('button.addTier');add.addEventListener('click',function(){tiers.insertBefore(makeTierRow(name,{threshold:1,input:price.input,output:price.output,cache_read:price.cache_read,cache_creation:price.cache_creation}),meta);toggle.textContent=t('pricing.tierCount',{count:tiers.querySelectorAll('.context-tier-row').length});});meta.appendChild(add);tiers.appendChild(meta);toggle.addEventListener('click',function(){tiers.hidden=!tiers.hidden;var cnt=tiers.querySelectorAll('.context-tier-row').length;toggle.textContent=(tiers.hidden?t('button.expandTiers'):t('button.collapseTiers'))+' '+t('pricing.tierCount',{count:cnt});});row.appendChild(tiers);if(pendingDeletedPrices.has(name))setPriceDeletedState(row,true);fragment.appendChild(row);});list.replaceChildren(fragment);document.getElementById('providerPriority').value=syncListText(syncSettings.provider_priority);document.getElementById('ignoredSuffixes').value=syncListText(syncSettings.ignored_suffixes);document.getElementById('syncMappings').value=syncMappingText(syncSettings.mappings);renderPricingStatus();}
+function renderPricingEditor(){var list=document.getElementById('priceList'),fragment=document.createDocumentFragment(),head=document.createElement('div');head.className='price-head';[t('pricing.model'),'Input','Output','Cache Read','Cache Creation',t('pricing.provenance')].forEach(function(value){var span=document.createElement('span');span.textContent=value;head.appendChild(span);});fragment.appendChild(head);var names=pricingNames();if(!names.length){var empty=document.createElement('div');empty.className='legend-empty';empty.textContent=cliModelsLoadedAt?t('pricing.noModels'):t('pricing.loadModelsHint');fragment.appendChild(empty);}names.forEach(function(name){var price=priceFor(name),row=document.createElement('div');row.className='price-row';row.dataset.model=name;var label=document.createElement('div');label.className='price-model';label.textContent=name;row.appendChild(label);row.appendChild(priceNumberInput('price-input',price.input,name+' Input'));row.appendChild(priceNumberInput('price-output',price.output,name+' Output'));row.appendChild(priceNumberInput('price-cache-read',price.cache_read,name+' Cache Read'));row.appendChild(priceNumberInput('price-cache-creation',price.cache_creation,name+' Cache Creation'));var provenance=document.createElement('div');provenance.className='price-provenance';var source=document.createElement('strong');source.textContent=price.source||(manualDraftModels.has(name)?t('pricing.manualDraftSource'):t('pricing.sourceUnset'));provenance.appendChild(source);var catalog=document.createElement('span');catalog.textContent=price.catalog_provider||price.catalog_model?t('pricing.catalogSource',{provider:price.catalog_provider||t('locale.unavailable'),model:price.catalog_model||t('locale.unavailable')}):t('pricing.manualSource');if(cliModelsLoadedAt&&!cliModelSet[name])catalog.textContent+=t('pricing.notInCatalog');provenance.appendChild(catalog);var hasSavedPrice=Object.prototype.hasOwnProperty.call(prices,name),isManualDraft=manualDraftModels.has(name);if(hasSavedPrice||isManualDraft){var removePrice=document.createElement('button');removePrice.type='button';removePrice.className='mini-button '+(hasSavedPrice?'remove-model-price':'remove-manual-model');removePrice.textContent=hasSavedPrice?t('button.deletePrice'):t('button.remove');removePrice.addEventListener('click',function(){if(hasSavedPrice){setPriceDeletedState(row,!pendingDeletedPrices.has(name));return;}manualDraftModels.delete(name);rerenderPricingEditor(name);manualModelInput.focus();});provenance.appendChild(removePrice);}row.appendChild(provenance);var toggle=document.createElement('button');toggle.type='button';toggle.className='mini-button price-tier-toggle';toggle.textContent=t('pricing.tierCount',{count:(price.context_tiers||[]).length});row.appendChild(toggle);var tiers=document.createElement('div');tiers.className='price-tiers context-tier-controls';tiers.hidden=true;var labels=document.createElement('div');labels.className='price-tier-row price-tier-labels';[t('pricing.threshold'),'Input','Output','Cache Read','Cache Creation',t('pricing.operation')].forEach(function(value){var span=document.createElement('span');span.textContent=value;labels.appendChild(span);});tiers.appendChild(labels);(price.context_tiers||[]).forEach(function(tier){tiers.appendChild(makeTierRow(name,tier));});var meta=document.createElement('div');meta.className='price-meta-row';var modeLabel=document.createElement('label');var modeText=document.createElement('span');modeText.textContent=t('pricing.accountingMode');var mode=document.createElement('select');mode.className='price-accounting-mode';[['',t('pricing.default')],['input_excludes_cache',t('pricing.inputExcludesCache')],['input_includes_cache',t('pricing.inputIncludesCache')]].forEach(function(optionValue){var option=document.createElement('option');option.value=optionValue[0];option.textContent=optionValue[1];if(price.accounting_mode===optionValue[0])option.selected=true;mode.appendChild(option);});modeLabel.appendChild(modeText);modeLabel.appendChild(mode);meta.appendChild(modeLabel);var add=document.createElement('button');add.type='button';add.className='mini-button add-context-tier';add.textContent=t('button.addTier');add.addEventListener('click',function(){tiers.insertBefore(makeTierRow(name,{threshold:1,input:price.input,output:price.output,cache_read:price.cache_read,cache_creation:price.cache_creation}),meta);toggle.textContent=t('pricing.tierCount',{count:tiers.querySelectorAll('.context-tier-row').length});});meta.appendChild(add);tiers.appendChild(meta);toggle.addEventListener('click',function(){tiers.hidden=!tiers.hidden;var cnt=tiers.querySelectorAll('.context-tier-row').length;toggle.textContent=(tiers.hidden?t('button.expandTiers'):t('button.collapseTiers'))+' '+t('pricing.tierCount',{count:cnt});});row.appendChild(tiers);row.appendChild(makeTimePricing(price));if(pendingDeletedPrices.has(name))setPriceDeletedState(row,true);fragment.appendChild(row);});list.replaceChildren(fragment);document.getElementById('providerPriority').value=syncListText(syncSettings.provider_priority);document.getElementById('ignoredSuffixes').value=syncListText(syncSettings.ignored_suffixes);document.getElementById('syncMappings').value=syncMappingText(syncSettings.mappings);renderPricingStatus();}
 function finishPricingDialogClose(token){if(token!==pricingDialogAnimationToken||!pricingDialog.classList.contains('is-closing'))return;clearTimeout(pricingDialogCloseTimer);pricingDialogCloseTimer=null;pricingDialog.classList.remove('is-open','is-closing');pricingDialog.close();if(pricingDialogRestoreFocus)document.getElementById('pricingButton').focus();pricingDialogRestoreFocus=false;}function closePricingDialog(restoreFocus){if(!pricingDialog.open)return;pricingDialogRestoreFocus=pricingDialogRestoreFocus||restoreFocus;if(pricingDialog.classList.contains('is-closing'))return;var token=++pricingDialogAnimationToken;clearTimeout(pricingDialogCloseTimer);pricingDialog.classList.remove('is-open');pricingDialog.classList.add('is-closing');if(reducedMotion){finishPricingDialogClose(token);return;}pricingDialogCloseTimer=setTimeout(function(){finishPricingDialogClose(token);},180);}function openPricing(){if(!fullModeEnabled||!fullModeManagementKey)return;clearCLIModelState();clearPricingDraft();renderPricingEditor();text('priceError','');var token=++pricingDialogAnimationToken;clearTimeout(pricingDialogCloseTimer);pricingDialogCloseTimer=null;pricingDialogRestoreFocus=false;pricingDialog.classList.remove('is-closing','is-open');if(!pricingDialog.open)pricingDialog.showModal();requestAnimationFrame(function(){if(token!==pricingDialogAnimationToken||!pricingDialog.open)return;pricingDialog.classList.add('is-open');var first=pricingDialog.querySelector('#cliModelsKeyInput');if(first)first.focus();});}
 function splitSyncValues(value){return String(value||'').split(/[\n,]+/).map(function(item){return item.trim();}).filter(Boolean);}
 function readSyncSettings(){var mappings=[],invalid='';String(document.getElementById('syncMappings').value||'').split(/\n+/).forEach(function(line){line=line.trim();if(!line)return;var split=line.indexOf('=');if(split<=0||split===line.length-1){invalid=t('error.invalidMapping');return;}mappings.push({source:line.slice(0,split).trim(),target:line.slice(split+1).trim()});});if(invalid)throw new Error(invalid);return {provider_priority:splitSyncValues(document.getElementById('providerPriority').value),ignored_suffixes:splitSyncValues(document.getElementById('ignoredSuffixes').value),mappings:mappings};}
-function collectPricing(){var next=Object.create(null),invalid='';document.querySelectorAll('#priceList>.price-row').forEach(function(row){if(pendingDeletedPrices.has(row.dataset.model))return;var name=row.dataset.model,base=priceFor(name),input=Number(row.querySelector('.price-input').value),output=Number(row.querySelector('.price-output').value),cacheRead=Number(row.querySelector('.price-cache-read').value),cacheCreation=Number(row.querySelector('.price-cache-creation').value),rates=[input,output,cacheRead,cacheCreation];if(rates.some(function(value){return !Number.isFinite(value)||value<0||value>1000000;})){invalid=t('error.invalidPrice');return;}var tiers=[];row.querySelectorAll('.context-tier-row').forEach(function(tierRow){var tier={threshold:Number(tierRow.querySelector('.tier-threshold').value),input:Number(tierRow.querySelector('.tier-input').value),output:Number(tierRow.querySelector('.tier-output').value),cache_read:Number(tierRow.querySelector('.tier-cache-read').value),cache_creation:Number(tierRow.querySelector('.tier-cache-creation').value)};if(!Number.isSafeInteger(tier.threshold)||tier.threshold<=0||[tier.input,tier.output,tier.cache_read,tier.cache_creation].some(function(value){return !Number.isFinite(value)||value<0||value>1000000;})){invalid=t('error.invalidTier');return;}tiers.push(tier);});if(invalid)return;tiers.sort(function(a,b){return a.threshold-b.threshold;});var value={input:input,output:output,cache_read:cacheRead,cache_creation:cacheCreation,context_tiers:tiers,service_tiers:base.service_tiers||{},accounting_mode:row.querySelector('.price-accounting-mode').value};if(base.source)value.source=base.source;if(base.catalog_provider)value.catalog_provider=base.catalog_provider;if(base.catalog_model)value.catalog_model=base.catalog_model;if(base.updated_at)value.updated_at=base.updated_at;if(Object.prototype.hasOwnProperty.call(prices,name)||manualDraftModels.has(name)||input>0||output>0||cacheRead>0||cacheCreation>0||tiers.length)next[name]=value;});if(invalid)throw new Error(invalid);return next;}
+function collectPricing(){var next=Object.create(null),invalid='';document.querySelectorAll('#priceList>.price-row').forEach(function(row){if(pendingDeletedPrices.has(row.dataset.model))return;var name=row.dataset.model,base=priceFor(name),input=Number(row.querySelector('.price-input').value),output=Number(row.querySelector('.price-output').value),cacheRead=Number(row.querySelector('.price-cache-read').value),cacheCreation=Number(row.querySelector('.price-cache-creation').value),rates=[input,output,cacheRead,cacheCreation];if(rates.some(function(value){return !Number.isFinite(value)||value<0||value>1000000;})){invalid=t('error.invalidPrice');return;}var tiers=[];row.querySelectorAll('.context-tier-row').forEach(function(tierRow){var tier={threshold:Number(tierRow.querySelector('.tier-threshold').value),input:Number(tierRow.querySelector('.tier-input').value),output:Number(tierRow.querySelector('.tier-output').value),cache_read:Number(tierRow.querySelector('.tier-cache-read').value),cache_creation:Number(tierRow.querySelector('.tier-cache-creation').value)};if(!Number.isSafeInteger(tier.threshold)||tier.threshold<=0||[tier.input,tier.output,tier.cache_read,tier.cache_creation].some(function(value){return !Number.isFinite(value)||value<0||value>1000000;})){invalid=t('error.invalidTier');return;}tiers.push(tier);});if(invalid)return;tiers.sort(function(a,b){return a.threshold-b.threshold;});var value={input:input,output:output,cache_read:cacheRead,cache_creation:cacheCreation,context_tiers:tiers,service_tiers:base.service_tiers||{},accounting_mode:row.querySelector('.price-accounting-mode').value};var timePricing=collectTimePricing(row);value.time_zone=timePricing.time_tiers.length?timePricing.time_zone:(base.time_zone||'');value.time_tiers=timePricing.time_tiers;if(base.source)value.source=base.source;if(base.catalog_provider)value.catalog_provider=base.catalog_provider;if(base.catalog_model)value.catalog_model=base.catalog_model;if(base.updated_at)value.updated_at=base.updated_at;if(Object.prototype.hasOwnProperty.call(prices,name)||manualDraftModels.has(name)||input>0||output>0||cacheRead>0||cacheCreation>0||tiers.length||value.time_tiers.length)next[name]=value;});if(invalid)throw new Error(invalid);return next;}
 function setPricingBusy(busy){document.getElementById('savePricing').disabled=busy;document.getElementById('syncPrices').disabled=busy;document.getElementById('loadCLIModels').disabled=busy;document.getElementById('cancelPricing').disabled=busy;document.getElementById('addManualModel').disabled=busy;cliModelsKeyInput.disabled=busy;manualModelInput.disabled=busy;}
 async function reloadPricesAndCosts(){var query=dateRangeQuery(),responses=await Promise.all([api(pricesURL),api(costsURL+'?'+query)]);applyPriceBook(responses[0]);currentCosts=responses[1];costQuery=query;costLoadError='';renderVisuals();await loadRequests();return responses;}
 async function savePricing(){var managementKey=fullModeManagementKey;if(!fullModeEnabled||!managementKey){text('priceError',t('fullMode.keyRequired'));return;}var next,settings;try{next=collectPricing();settings=readSyncSettings();}catch(error){text('priceError',error.message);return;}setPricingBusy(true);text('priceError','');try{await api(savePricesURL,{method:'PUT',headers:{'Content-Type':'application/json','Authorization':'Bearer '+managementKey},body:JSON.stringify({prices:next,sync_settings:settings})});await reloadPricesAndCosts();closePricingDialog(true);text('status',t('status.saved',{revision:priceBookRevision,time:new Date().toLocaleTimeString(formatterLocale)}));}catch(error){text('priceError',error.message);}finally{setPricingBusy(false);}}
 async function syncPricing(){var managementKey=fullModeManagementKey;if(!fullModeEnabled||!managementKey){text('priceError',t('fullMode.keyRequired'));return;}var settings;try{settings=readSyncSettings();}catch(error){text('priceError',error.message);return;}setPricingBusy(true);text('priceError','');text('lastSyncStatus',t('pricing.syncingCatalog'));try{var models=await fetchCLIModels(false);text('lastSyncStatus',t('pricing.syncingModels',{count:fmt(models.length)}));await api(syncPricesURL,{method:'POST',headers:{'Content-Type':'application/json','Authorization':'Bearer '+managementKey},body:JSON.stringify({source:'models.dev',models:models,sync_settings:settings}),timeout:25000});await reloadPricesAndCosts();renderPricingEditor();text('status',t('status.syncComplete',{count:fmt(models.length),revision:priceBookRevision,time:new Date().toLocaleTimeString(formatterLocale)}));}catch(error){text('priceError',error.message);text('lastSyncStatus',t('pricing.syncFailed',{message:error.message}));}finally{setPricingBusy(false);}}
 function csvCell(value){var string=value===undefined||value===null?'':String(value);if(/^[=+\-@]/.test(string))string="'"+string;return '"'+string.replace(/"/g,'""')+'"';}
-async function exportCSV(){if(!currentData)return;var button=document.getElementById('exportCSV'),rows=[t('export.csvHeaders').split(',')],offset=0,total=0,range=dateRangeFilePart();button.disabled=true;text('status',t('status.preparingCSV'));try{do{var url=requestsURL+'?'+dateRangeQuery()+'&offset='+offset+'&limit=500';if(selectedModel)url+='&model='+encodeURIComponent(selectedModel);var page=await api(url);total=Number(page.total||0);(page.items||[]).forEach(function(record){var name=modelName(record.model),estimated=record.estimated_cost||{};if(hiddenModels.has(name))return;rows.push([record.time,name,record.source,record.service_tier,translateRawResult(record.result,record.failed),record.ttft_ns,record.generation_ns,Number(record.tps||0).toFixed(4),record.reasoning_effort,record.input_tokens,record.output_tokens,record.reasoning_tokens,record.cache_read_tokens,record.cache_creation_tokens,record.total_tokens,record.cache_hit?t('cache.hit'):t('cache.miss'),estimated.priced?Number(estimated.input_usd||0).toFixed(8):'',estimated.priced?Number(estimated.output_usd||0).toFixed(8):'',estimated.priced?Number(estimated.cache_read_usd||0).toFixed(8):'',estimated.priced?Number(estimated.cache_creation_usd||0).toFixed(8):'',estimated.priced?Number(estimated.total_usd||0).toFixed(8):'',estimated.source||'',estimated.accounting_mode||'',estimated.tier_threshold||'']);});offset+=(page.items||[]).length;if(!(page.items||[]).length)break;}while(offset<total);var csv='\ufeff'+rows.map(function(row){return row.map(csvCell).join(',');}).join('\r\n');downloadBlob(new Blob([csv],{type:'text/csv;charset=utf-8'}),'token-requests-'+range+'.csv');text('status',t('status.exported',{count:fmt(rows.length-1)}));closeExportMenu();}finally{button.disabled=false;}}
+async function exportCSV(){if(!currentData)return;var button=document.getElementById('exportCSV'),rows=[t('export.csvHeaders').split(',')],offset=0,total=0,range=dateRangeFilePart();button.disabled=true;text('status',t('status.preparingCSV'));try{do{var url=requestsURL+'?'+dateRangeQuery()+'&offset='+offset+'&limit=500';if(selectedModel)url+='&model='+encodeURIComponent(selectedModel);var page=await api(url);total=Number(page.total||0);(page.items||[]).forEach(function(record){var name=modelName(record.model),estimated=record.estimated_cost||{};if(hiddenModels.has(name))return;rows.push([record.time,name,record.source,record.service_tier,translateRawResult(record.result,record.failed),record.ttft_ns,record.generation_ns,Number(record.tps||0).toFixed(4),record.reasoning_effort,record.input_tokens,record.output_tokens,record.reasoning_tokens,record.cache_read_tokens,record.cache_creation_tokens,record.total_tokens,record.cache_hit?t('cache.hit'):t('cache.miss'),estimated.priced?Number(estimated.input_usd||0).toFixed(8):'',estimated.priced?Number(estimated.output_usd||0).toFixed(8):'',estimated.priced?Number(estimated.cache_read_usd||0).toFixed(8):'',estimated.priced?Number(estimated.cache_creation_usd||0).toFixed(8):'',estimated.priced?Number(estimated.total_usd||0).toFixed(8):'',estimated.source||'',estimated.accounting_mode||'',estimated.tier_threshold||'',estimated.price_time_tier||'',estimated.price_time_zone||'']);});offset+=(page.items||[]).length;if(!(page.items||[]).length)break;}while(offset<total);var csv='\ufeff'+rows.map(function(row){return row.map(csvCell).join(',');}).join('\r\n');downloadBlob(new Blob([csv],{type:'text/csv;charset=utf-8'}),'token-requests-'+range+'.csv');text('status',t('status.exported',{count:fmt(rows.length-1)}));closeExportMenu();}finally{button.disabled=false;}}
 function canvasText(ctx,value,x,y,size,color,weight,align){ctx.fillStyle=color;ctx.font=(weight||400)+' '+size+'px "Segoe UI","Microsoft YaHei",sans-serif';ctx.textAlign=align||'left';ctx.textBaseline='alphabetic';ctx.fillText(String(value),x,y);}
 function roundedRect(ctx,x,y,w,h,r,fill,stroke){ctx.beginPath();if(ctx.roundRect)ctx.roundRect(x,y,w,h,r);else ctx.rect(x,y,w,h);ctx.fillStyle=fill;ctx.fill();if(stroke){ctx.strokeStyle=stroke;ctx.lineWidth=1;ctx.stroke();}}
 function exportPNG(){if(!currentData)return;var canvas=document.createElement('canvas');canvas.width=1600;canvas.height=980;var ctx=canvas.getContext('2d'),style=getComputedStyle(document.documentElement),bg=style.getPropertyValue('--bg-secondary').trim(),panel=style.getPropertyValue('--bg-primary').trim(),border=style.getPropertyValue('--border-color').trim(),primary=style.getPropertyValue('--text-primary').trim(),secondary=style.getPropertyValue('--text-secondary').trim(),tertiary=style.getPropertyValue('--text-tertiary').trim(),input=style.getPropertyValue('--input-color').trim(),output=style.getPropertyValue('--output-color').trim(),cacheRead=style.getPropertyValue('--cache-read-color').trim(),cacheHit=style.getPropertyValue('--cache-hit-color').trim();ctx.fillStyle=bg;ctx.fillRect(0,0,1600,980);canvasText(ctx,t('export.pngTitle'),64,70,34,primary,750);canvasText(ctx,t('export.pngRange',{range:currentData.range,time:new Date().toLocaleString(formatterLocale)}),64,101,15,secondary,400);var groups=visibleGroups(),summary={};groups.forEach(function(group){sumInto(summary,group);});var models=groupModels(groups),top=models.slice().sort(function(a,b){return b.requests-a.requests;})[0],costSummary=visibleCostSummary(),cards=[[t('card.totalTokens'),formatTokenTotal(summary.total_tokens)],[t('card.totalCost'),costSummary?money(costSummary.total_usd):t('value.unavailable')],[t('card.requests'),fmt(summary.requests)],[t('card.topModel'),top?top.model:t('locale.unavailable')]];cards.forEach(function(card,index){var x=64+index*374;roundedRect(ctx,x,130,350,126,14,panel,border);canvasText(ctx,card[0],x+22,164,14,secondary,650);canvasText(ctx,card[1],x+22,216,index===3?23:30,primary,750);});roundedRect(ctx,64,282,1000,620,14,panel,border);canvasText(ctx,t('trend.title'),88,323,18,primary,750);canvasText(ctx,selectedModel?t('export.model',{model:selectedModel}):t('export.visibleModels'),88,348,12,tertiary,400);var trend=lastTrend.length?lastTrend:aggregateTrend(),chartX=116,chartY=382,chartW=900,chartH=452,showInput=trendSeriesVisible('input'),showOutput=trendSeriesVisible('output'),showCacheRead=trendSeriesVisible('cacheRead'),showCacheHit=trendSeriesVisible('cacheHitRate'),max=trend.reduce(function(value,p){return Math.max(value,pointStackTotal(p));},0);if(max<=0)max=1;ctx.strokeStyle=border;ctx.lineWidth=1;for(var grid=0;grid<=4;grid++){var gy=chartY+chartH*grid/4;ctx.beginPath();ctx.moveTo(chartX,gy);ctx.lineTo(chartX+chartW,gy);ctx.stroke();}var slot=trend.length?chartW/trend.length:chartW,barW=Math.max(3,Math.min(34,slot*.62)),cacheLine=[];trend.forEach(function(point,index){var x=chartX+slot*index+(slot-barW)/2,inputH=showInput?point.input/max*chartH:0,outputH=showOutput?point.output/max*chartH:0,cacheReadH=showCacheRead?point.cacheRead/max*chartH:0;if(showInput&&inputH>0){ctx.fillStyle=input;ctx.fillRect(x,chartY+chartH-inputH,barW,inputH);}if(showOutput&&outputH>0){ctx.fillStyle=output;ctx.fillRect(x,chartY+chartH-inputH-outputH,barW,outputH);}if(showCacheRead&&cacheReadH>0){ctx.fillStyle=cacheRead;ctx.fillRect(x,chartY+chartH-inputH-outputH-cacheReadH,barW,cacheReadH);}if(showCacheHit)cacheLine.push({x:x+barW/2,y:chartY+chartH*(1-point.cacheHitRate/100)});});if(showCacheHit&&cacheLine.length){ctx.save();ctx.strokeStyle=cacheHit;ctx.lineWidth=3;ctx.setLineDash([9,7]);ctx.beginPath();cacheLine.forEach(function(point,index){if(index)ctx.lineTo(point.x,point.y);else ctx.moveTo(point.x,point.y);});ctx.stroke();ctx.restore();}if(!trend.length)canvasText(ctx,t('chart.noCalls'),chartX+chartW/2,chartY+chartH/2,17,tertiary,600,'center');else if(!(showInput||showOutput||showCacheRead||showCacheHit))canvasText(ctx,t('trend.series.allHidden'),chartX+chartW/2,chartY+chartH/2,17,tertiary,600,'center');roundedRect(ctx,1088,282,448,620,14,panel,border);canvasText(ctx,t('export.modelShare')+' · '+modelShareMetricLabel(),1112,323,18,primary,750);var pieAll=groupModels(modelRows()),pieModels=pieAll.filter(function(item){return !hiddenModels.has(item.model);}),pieTotal=pieModels.reduce(function(sum,item){return sum+modelShareMetricValue(item);},0),angle=-Math.PI/2;pieModels.forEach(function(item){var next=angle+(pieTotal?modelShareMetricValue(item)/pieTotal*Math.PI*2:0);ctx.beginPath();ctx.arc(1312,525,118,angle,next);ctx.strokeStyle=colorFor(pieAll.indexOf(item));ctx.lineWidth=38;ctx.stroke();angle=next;});canvasText(ctx,formatModelShareMetric(pieTotal,true),1312,524,28,primary,750,'center');canvasText(ctx,modelShareMetricLabel(),1312,548,12,tertiary,400,'center');pieModels.slice(0,8).forEach(function(item,index){var y=700+index*23;ctx.fillStyle=colorFor(pieAll.indexOf(item));ctx.fillRect(1120,y-9,11,11);canvasText(ctx,item.model,1143,y,12,primary,600);canvasText(ctx,(pieTotal?modelShareMetricValue(item)/pieTotal*100:0).toFixed(1)+'%',1500,y,12,secondary,600,'right');});canvas.toBlob(function(blob){if(blob)downloadBlob(blob,'token-dashboard-'+document.getElementById('range').value+'.png');},'image/png');closeExportMenu();}
diff --git a/internal/plugin/dashboard_date_range_browser_test.go b/internal/plugin/dashboard_date_range_browser_test.go
index bc7daa7..795acaf 100644
--- a/internal/plugin/dashboard_date_range_browser_test.go
+++ b/internal/plugin/dashboard_date_range_browser_test.go
@@ -103,3 +103,11 @@ func TestDashboardDateRangeCalendarAmericaLosAngelesDSTInBrowser(t *testing.T) {
 func TestDashboardTokenUnitCyclesThroughBillionsInBrowser(t *testing.T) {
 	runDashboardDateRangeBrowserTest(t, "token-unit", "dashboard token-unit browser regression failed")
 }
+
+func TestDashboardDateRangeKeepsSavedRangeWhenRecentlyOpenedInBrowser(t *testing.T) {
+	runDashboardDateRangeBrowserTest(t, "recent-open", "dashboard recent-open date range browser regression failed")
+}
+
+func TestDashboardDateRangeResetsToTodayAfterInactivityInBrowser(t *testing.T) {
+	runDashboardDateRangeBrowserTest(t, "expired-open", "dashboard expired-open date range browser regression failed")
+}
diff --git a/internal/plugin/dashboard_test.go b/internal/plugin/dashboard_test.go
index 258177b..df1af75 100644
--- a/internal/plugin/dashboard_test.go
+++ b/internal/plugin/dashboard_test.go
@@ -268,6 +268,9 @@ func TestDashboardIncludesInteractiveAnalyticsFeatures(t *testing.T) {
 		`hidden_request_columns:Array.from(hiddenRequestColumns)`,
 		`hidden_dimension_columns:Array.from(hiddenDimensionColumns)`,
 		`time_range_mode:appliedRangeMode`,
+		`last_dashboard_open_at:lastDashboardOpenAt`,
+		`function markDashboardOpened()`,
+		`setAppliedTodayRange()`,
 		`params.set('time_range_mode',value.time_range_mode)`,
 		`params.set('save','1')`,
 		`params.append('hidden_request_column',key)`,
diff --git a/internal/plugin/dashboard_time_pricing_browser_test.go b/internal/plugin/dashboard_time_pricing_browser_test.go
new file mode 100644
index 0000000..5b9a96f
--- /dev/null
+++ b/internal/plugin/dashboard_time_pricing_browser_test.go
@@ -0,0 +1,33 @@
+package plugin
+
+import (
+	"os"
+	"os/exec"
+	"path/filepath"
+	"testing"
+)
+
+func TestTimePricingEditorInBrowser(t *testing.T) {
+	node, err := exec.LookPath("node")
+	if err != nil {
+		browserTestUnavailable(t, "Node.js", err)
+	}
+	chrome, err := resolveBrowserTestChrome()
+	if err != nil {
+		browserTestUnavailable(t, "Google Chrome (set CHROME_PATH to its executable)", err)
+	}
+	if _, err := os.Stat(filepath.Join("..", "..", "node_modules", "playwright-core", "package.json")); err != nil {
+		browserTestUnavailable(t, "playwright-core (run npm ci)", err)
+	}
+
+	htmlPath := filepath.Join(t.TempDir(), "dashboard.html")
+	if err := os.WriteFile(htmlPath, []byte(fullDashboardHTML), 0o600); err != nil {
+		t.Fatalf("write full dashboard response body: %v", err)
+	}
+
+	command := exec.Command(node, filepath.Join("..", "..", "test", "dashboard_time_pricing.mjs"), htmlPath, chrome)
+	command.Env = append(os.Environ(), "TZ=UTC")
+	if output, err := command.CombinedOutput(); err != nil {
+		t.Fatalf("time pricing browser regression failed: %v\n%s\nInstall the pinned browser-test dependency with `npm ci`; this test uses the installed Google Chrome and does not download a browser.", err, output)
+	}
+}
diff --git a/internal/plugin/locales/en.json b/internal/plugin/locales/en.json
index bfb1f54..0702329 100644
--- a/internal/plugin/locales/en.json
+++ b/internal/plugin/locales/en.json
@@ -251,7 +251,7 @@
   "pricing.unpriced": "Unpriced",
   "pricing.saved": "Saved",
   "pricing.notSet": "Not set",
-  "export.csvHeaders": "Time,Model,Source,Tier,Result,Time to first token (ns),Generation time (ns),TPS,Reasoning effort,Input,Output,Reasoning,Cache read,Cache creation,Total Tokens,Cache hit,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,Price source,Accounting mode,Price Tier threshold",
+  "export.csvHeaders": "Time,Model,Source,Tier,Result,Time to first token (ns),Generation time (ns),TPS,Reasoning effort,Input,Output,Reasoning,Cache read,Cache creation,Total Tokens,Cache hit,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,Price source,Accounting mode,Price Tier threshold,Price time period,Price time zone",
   "export.pngTitle": "Token Usage Analytics",
   "export.pngRange": "Range: {range} · Exported: {time}",
   "export.visibleModels": "All visible models",
@@ -339,5 +339,15 @@
   "apiKey.sourceMissing": "Client API Key was not provided",
   "apiKey.defaultSecretWarning": "The public default secret 123456 is active. Anyone who obtains the database or a backup can decrypt stored API Keys. Configure a custom secret of at least 32 bytes.",
   "apiKey.labelTooLong": "The label must be at most 120 characters.",
-  "apiKey.saveFailed": "Failed to save the API Key label."
+  "apiKey.saveFailed": "Failed to save the API Key label.",
+  "pricing.timeTitle": "Time pricing",
+  "pricing.timeZone": "Time zone (IANA)",
+  "pricing.timeName": "Period name",
+  "pricing.timeDays": "Weekdays (1=Mon…7=Sun; blank=every day)",
+  "pricing.timeStart": "Start",
+  "pricing.timeEnd": "End",
+  "pricing.timeAdd": "Add period",
+  "pricing.timeHelp": "Use request time; start included, end excluded. Overnight periods belong to the starting day. Unmatched periods use base/service prices; context tiers take precedence. Changes recalculate historical estimates.",
+  "pricing.timeInvalid": "Invalid time pricing: check names, zone, weekdays and times (maximum 32 periods).",
+  "pricing.timeOverlap": "Time periods overlap."
 }
diff --git a/internal/plugin/locales/ru.json b/internal/plugin/locales/ru.json
index fbc7e87..ec5b3a0 100644
--- a/internal/plugin/locales/ru.json
+++ b/internal/plugin/locales/ru.json
@@ -251,7 +251,7 @@
   "pricing.unpriced": "Без цены",
   "pricing.saved": "Сохранено",
   "pricing.notSet": "Не задано",
-  "export.csvHeaders": "Time,Model,Source,Tier,Result,Time to first token (ns),Generation time (ns),TPS,Reasoning effort,Input,Output,Reasoning,Cache read,Cache creation,Total Tokens,Cache hit,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,Price source,Accounting mode,Price Tier threshold",
+  "export.csvHeaders": "Time,Model,Source,Tier,Result,Time to first token (ns),Generation time (ns),TPS,Reasoning effort,Input,Output,Reasoning,Cache read,Cache creation,Total Tokens,Cache hit,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,Price source,Accounting mode,Price Tier threshold,Тарифный период,Часовой пояс тарифа",
   "export.pngTitle": "Аналитика использования токенов",
   "export.pngRange": "Период: {range} · Экспортировано: {time}",
   "export.visibleModels": "Все видимые модели",
@@ -339,5 +339,15 @@
   "apiKey.sourceMissing": "Клиентский API Key не был предоставлен",
   "apiKey.defaultSecretWarning": "Используется общедоступный секрет по умолчанию 123456. Любой, кто получит базу данных или резервную копию, сможет расшифровать сохраненные API Key. Настройте собственный секрет длиной не менее 32 байт.",
   "apiKey.labelTooLong": "Метка должна содержать не более 120 символов.",
-  "apiKey.saveFailed": "Не удалось сохранить метку API Key."
+  "apiKey.saveFailed": "Не удалось сохранить метку API Key.",
+  "pricing.timeTitle": "Тарифы по времени",
+  "pricing.timeZone": "Часовой пояс (IANA)",
+  "pricing.timeName": "Название периода",
+  "pricing.timeDays": "Дни (1=пн…7=вс; пусто=ежедневно)",
+  "pricing.timeStart": "Начало",
+  "pricing.timeEnd": "Конец",
+  "pricing.timeAdd": "Добавить период",
+  "pricing.timeHelp": "Используется время запроса: начало включено, конец исключён. Ночной период относится к дню начала. Вне периодов действуют базовые тарифы; контекстные тарифы имеют приоритет. Изменения пересчитывают историю.",
+  "pricing.timeInvalid": "Проверьте название, пояс, дни и время (не более 32 периодов).",
+  "pricing.timeOverlap": "Периоды пересекаются."
 }
diff --git a/internal/plugin/locales/zh-CN.json b/internal/plugin/locales/zh-CN.json
index 8f51b5b..848a1cf 100644
--- a/internal/plugin/locales/zh-CN.json
+++ b/internal/plugin/locales/zh-CN.json
@@ -251,7 +251,7 @@
   "pricing.unpriced": "未定价",
   "pricing.saved": "已保存",
   "pricing.notSet": "未设置",
-  "export.csvHeaders": "时间,模型名称,来源,Tier,结果,首字延迟(ns),生成时间(ns),TPS,思考强度,输入,输出,思考,缓存读取,缓存创建,总Token数,缓存命中,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,价格来源,计费模式,价格Tier阈值",
+  "export.csvHeaders": "时间,模型名称,来源,Tier,结果,首字延迟(ns),生成时间(ns),TPS,思考强度,输入,输出,思考,缓存读取,缓存创建,总Token数,缓存命中,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,价格来源,计费模式,价格Tier阈值,计费时段,计费时区",
   "export.pngTitle": "Token 用量统计",
   "export.pngRange": "范围：{range} · 导出：{time}",
   "export.visibleModels": "全部可见模型",
@@ -339,5 +339,15 @@
   "apiKey.sourceMissing": "未提供客户端 API Key",
   "apiKey.defaultSecretWarning": "当前使用公开默认密钥 123456。任何获得数据库或备份的人都可以解密其中保存的 API Key。请改用至少 32 字节的自定义密钥。",
   "apiKey.labelTooLong": "备注最多 120 个字符。",
-  "apiKey.saveFailed": "保存 API Key 备注失败。"
+  "apiKey.saveFailed": "保存 API Key 备注失败。",
+  "pricing.timeTitle": "峰谷定价",
+  "pricing.timeZone": "时区（IANA）",
+  "pricing.timeName": "时段名称",
+  "pricing.timeDays": "星期（1=周一…7=周日；留空为每天）",
+  "pricing.timeStart": "开始时间",
+  "pricing.timeEnd": "结束时间",
+  "pricing.timeAdd": "添加时段",
+  "pricing.timeHelp": "按请求时间计费，包含开始、不包含结束。跨午夜归属起始日；未命中使用基础/服务等级价格，上下文阶梯优先。修改后重新估算历史费用。",
+  "pricing.timeInvalid": "时间价格无效：请检查名称、时区、星期和时间（最多32个时段）。",
+  "pricing.timeOverlap": "价格时段重叠。"
 }
diff --git a/internal/plugin/locales/zh-TW.json b/internal/plugin/locales/zh-TW.json
index 153219f..32bf071 100644
--- a/internal/plugin/locales/zh-TW.json
+++ b/internal/plugin/locales/zh-TW.json
@@ -251,7 +251,7 @@
   "pricing.unpriced": "未定價",
   "pricing.saved": "已保存",
   "pricing.notSet": "未設置",
-  "export.csvHeaders": "時間,模型名稱,來源,Tier,結果,首字延遲(ns),生成時間(ns),TPS,思考強度,輸入,輸出,思考,快取讀取,快取創建,總Token數,快取命中,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,價格來源,計費模式,價格Tier閾值",
+  "export.csvHeaders": "時間,模型名稱,來源,Tier,結果,首字延遲(ns),生成時間(ns),TPS,思考強度,輸入,輸出,思考,快取讀取,快取創建,總Token數,快取命中,Input USD,Output USD,Cache Read USD,Cache Creation USD,Total USD,價格來源,計費模式,價格Tier閾值,計費時段,計費時區",
   "export.pngTitle": "Token 用量統計",
   "export.pngRange": "範圍：{range} · 導出：{time}",
   "export.visibleModels": "全部可見模型",
@@ -339,5 +339,15 @@
   "apiKey.sourceMissing": "未提供用戶端 API Key",
   "apiKey.defaultSecretWarning": "目前使用公開預設密鑰 123456。任何取得資料庫或備份的人都可以解密其中儲存的 API Key。請改用至少 32 位元組的自訂密鑰。",
   "apiKey.labelTooLong": "備註最多 120 個字元。",
-  "apiKey.saveFailed": "儲存 API Key 備註失敗。"
+  "apiKey.saveFailed": "儲存 API Key 備註失敗。",
+  "pricing.timeTitle": "峰谷定價",
+  "pricing.timeZone": "時區（IANA）",
+  "pricing.timeName": "時段名稱",
+  "pricing.timeDays": "星期（1=週一…7=週日；留空為每天）",
+  "pricing.timeStart": "開始時間",
+  "pricing.timeEnd": "結束時間",
+  "pricing.timeAdd": "新增時段",
+  "pricing.timeHelp": "依請求時間計費，包含開始、不包含結束。跨午夜歸屬起始日；未命中使用基礎/服務等級價格，上下文階梯優先。修改後重新估算歷史費用。",
+  "pricing.timeInvalid": "時間價格無效：請檢查名稱、時區、星期與時間（最多32個時段）。",
+  "pricing.timeOverlap": "價格時段重疊。"
 }
diff --git a/internal/plugin/management.go b/internal/plugin/management.go
index 0478dac..0480fb7 100644
--- a/internal/plugin/management.go
+++ b/internal/plugin/management.go
@@ -125,7 +125,7 @@ func (r *pluginRuntime) registerManagement(raw []byte) (managementRegistrationRe
 			{
 				Method:      http.MethodPut,
 				Path:        "/plugins/" + pluginID + "/prices",
-				Description: "Persist per-model input, output, cache, and context-tier token prices.",
+				Description: "Persist per-model token prices, context tiers, and weekly time-of-use schedules.",
 			},
 			{
 				Method:      http.MethodPost,
@@ -786,7 +786,7 @@ func dashboardPreferencesFromQuery(query map[string][]string) (DashboardPreferen
 	allowed := map[string]struct{}{
 		"save": {}, "request_page_size": {}, "dimension_page_size": {},
 		"hidden_request_column": {}, "hidden_dimension_column": {}, "time_range_mode": {},
-		"token_display_mode": {}, "time_range_start": {}, "time_range_end": {},
+		"token_display_mode": {}, "time_range_start": {}, "time_range_end": {}, "last_dashboard_open_at": {},
 	}
 	for key := range query {
 		if _, ok := allowed[key]; !ok {
@@ -820,6 +820,10 @@ func dashboardPreferencesFromQuery(query map[string][]string) (DashboardPreferen
 	if err != nil {
 		return DashboardPreferences{}, err
 	}
+	lastDashboardOpenAt, err := optionalDashboardPreference(query, "last_dashboard_open_at")
+	if err != nil {
+		return DashboardPreferences{}, err
+	}
 	return DashboardPreferences{
 		RequestPageSize:        requestPageSize,
 		DimensionPageSize:      dimensionPageSize,
@@ -829,6 +833,7 @@ func dashboardPreferencesFromQuery(query map[string][]string) (DashboardPreferen
 		TokenDisplayMode:       tokenDisplayMode,
 		TimeRangeStart:         timeRangeStart,
 		TimeRangeEnd:           timeRangeEnd,
+		LastDashboardOpenAt:    lastDashboardOpenAt,
 	}, nil
 }
 
diff --git a/internal/plugin/management_test.go b/internal/plugin/management_test.go
index 2a90623..73872d6 100644
--- a/internal/plugin/management_test.go
+++ b/internal/plugin/management_test.go
@@ -832,6 +832,7 @@ func TestDashboardPreferencesManagementSaveRoute(t *testing.T) {
 		HiddenRequestColumns: []string{"model", "source"},
 		TimeRangeMode:        "last_7_days",
 		TokenDisplayMode:     "B",
+		LastDashboardOpenAt:  "2026-08-23T04:00:00Z",
 	})
 	if err != nil {
 		t.Fatal(err)
@@ -841,7 +842,7 @@ func TestDashboardPreferencesManagementSaveRoute(t *testing.T) {
 		t.Fatalf("management preferences save response = %+v body=%s", response, response.Body)
 	}
 	var saved DashboardPreferences
-	if err := json.Unmarshal(response.Body, &saved); err != nil || saved.RequestPageSize != 25 || saved.DimensionPageSize != 50 || len(saved.HiddenRequestColumns) != 2 || saved.TimeRangeMode != "last_7_days" || saved.TokenDisplayMode != "B" {
+	if err := json.Unmarshal(response.Body, &saved); err != nil || saved.RequestPageSize != 25 || saved.DimensionPageSize != 50 || len(saved.HiddenRequestColumns) != 2 || saved.TimeRangeMode != "last_7_days" || saved.TokenDisplayMode != "B" || saved.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
 		t.Fatalf("saved preferences payload = %s, err = %v", response.Body, err)
 	}
 
@@ -856,7 +857,7 @@ func TestDashboardPreferencesManagementSaveRoute(t *testing.T) {
 		t.Fatalf("resource preferences read response = %+v body=%s", response, response.Body)
 	}
 	saved = DashboardPreferences{}
-	if err := json.Unmarshal(response.Body, &saved); err != nil || saved.RequestPageSize != 25 || saved.DimensionPageSize != 50 || saved.TokenDisplayMode != "B" {
+	if err := json.Unmarshal(response.Body, &saved); err != nil || saved.RequestPageSize != 25 || saved.DimensionPageSize != 50 || saved.TokenDisplayMode != "B" || saved.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
 		t.Fatalf("stored preferences payload = %s, err = %v", response.Body, err)
 	}
 
diff --git a/internal/plugin/persistence.go b/internal/plugin/persistence.go
index 033f99e..906f2dc 100644
--- a/internal/plugin/persistence.go
+++ b/internal/plugin/persistence.go
@@ -35,9 +35,17 @@ var (
 	apiKeyGenerationsKey    = []byte("api_key_crypto_generations")
 	apiKeyNextGenerationKey = []byte("api_key_next_generation")
 	apiKeyLabelsKey         = []byte("api_key_labels")
+	apiKeyCatalogKey        = []byte("api_key_catalog")
+	observedModelsKey       = []byte("observed_models")
 )
 
-const persistenceSchemaVersion uint64 = 9
+const persistenceSchemaVersion uint64 = 10
+
+const usageSourcesSchemaVersion uint64 = 9
+
+// aggregateHotWindow bounds the amount of aggregate data restored into memory.
+// Older data remains available through actor-owned range reads.
+const aggregateHotWindow = 24 * time.Hour
 
 const (
 	maxAPIKeyLabels     = 10_000
@@ -168,6 +176,7 @@ type configResult struct {
 	err         error
 }
 type closeCommand struct{ resp chan error }
+type rebuildAPIKeyCatalogCommand struct{ resp chan error }
 
 const maxDatabaseBackupBytes = 64 << 20
 
@@ -242,10 +251,101 @@ type storeActor struct {
 	dashboardPreferences DashboardPreferences
 	apiKeyCiphertexts    map[string]string
 	apiKeyLabels         map[string]string
+	apiKeyCatalog        map[string]apiKeyCatalogEntry
+	persistedAggregates  map[aggregateKey]struct{}
+	observedModelCounts  map[string]uint64
+	observedModelsReady  bool
+	apiKeyCatalogHealthy bool
 	activeGeneration     uint64
 	generations          map[uint64]APIKeyCryptoGeneration
 }
 
+type apiKeyCatalogEntry struct {
+	Ciphertext string `json:"ciphertext,omitempty"`
+	Hours      uint64 `json:"hours"`
+	Requests   uint64 `json:"requests"`
+}
+
+func loadObservedModels(meta *bolt.Bucket) (map[string]uint64, error) {
+	models := make(map[string]uint64)
+	raw := meta.Get(observedModelsKey)
+	if len(raw) == 0 {
+		return nil, nil
+	}
+	if err := json.Unmarshal(raw, &models); err != nil {
+		return nil, fmt.Errorf("decode observed models: %w", err)
+	}
+	for model, count := range models {
+		if strings.TrimSpace(model) == "" || count == 0 {
+			return nil, errors.New("observed models index contains invalid entry")
+		}
+	}
+	return models, nil
+}
+
+func saveObservedModels(meta *bolt.Bucket, models map[string]uint64) error {
+	if len(models) == 0 {
+		return meta.Delete(observedModelsKey)
+	}
+	encoded, err := json.Marshal(models)
+	if err != nil {
+		return fmt.Errorf("encode observed models: %w", err)
+	}
+	return meta.Put(observedModelsKey, encoded)
+}
+
+func updateObservedModelCount(models map[string]uint64, dimensions Dimensions, delta int) error {
+	model := strings.TrimSpace(dimensions.Model)
+	if model == "" || models == nil {
+		return nil
+	}
+	count := models[model]
+	if delta > 0 {
+		models[model] = count + uint64(delta)
+		return nil
+	}
+	decrement := uint64(-delta)
+	if count < decrement {
+		return fmt.Errorf("observed model count underflow for %q", model)
+	}
+	count -= decrement
+	if count == 0 {
+		delete(models, model)
+	} else {
+		models[model] = count
+	}
+	return nil
+}
+
+func buildObservedModels(hours *bolt.Bucket, cutoff int64) (map[string]uint64, error) {
+	models := make(map[string]uint64)
+	if err := hours.ForEach(func(hourKey, value []byte) error {
+		if value != nil {
+			return nil
+		}
+		if decodeInt64(hourKey) < cutoff {
+			return nil
+		}
+		hour := hours.Bucket(hourKey)
+		if hour == nil {
+			return nil
+		}
+		return hour.ForEach(func(dimensionKey, value []byte) error {
+			if value == nil {
+				return errors.New("hour bucket contains nested bucket")
+			}
+			var dimensions Dimensions
+			if err := json.Unmarshal(dimensionKey, &dimensions); err != nil {
+				return fmt.Errorf("decode dimensions while building observed models: %w", err)
+			}
+			return updateObservedModelCount(models, dimensions, 1)
+		})
+	}); err != nil {
+		return nil, err
+	}
+	return models, nil
+}
+
 func openStore(config Config) (*Store, error) {
 	crypto, err := deriveCryptoContext(config.APIKeySecret)
 	if err != nil {
@@ -275,6 +375,9 @@ func openStoreWithCrypto(config Config, crypto cryptoContext) (*Store, error) {
 		dashboardPreferences: defaultDashboardPreferences(),
 		apiKeyCiphertexts:    make(map[string]string),
 		apiKeyLabels:         make(map[string]string),
+		apiKeyCatalog:        make(map[string]apiKeyCatalogEntry),
+		observedModelCounts:  make(map[string]uint64),
+		apiKeyCatalogHealthy: true,
 	}
 	if err := actor.initialize(); err != nil {
 		_ = db.Close()
@@ -417,6 +520,17 @@ func (s *Store) ResolveAPIKeyHash(hash string) (string, error) {
 	return result.ref, result.err
 }
 
+// RebuildAPIKeyCatalog explicitly rebuilds the derived API-key index. It is
+// intentionally separate from store initialization so a missing or damaged
+// index never turns registration into an unbounded scan.
+func (s *Store) RebuildAPIKeyCatalog() error {
+	resp := make(chan error, 1)
+	if err := s.send(rebuildAPIKeyCatalogCommand{resp: resp}); err != nil {
+		return err
+	}
+	return <-resp
+}
+
 func (s *Store) SaveDashboardPreferences(preferences DashboardPreferences) (DashboardPreferences, error) {
 	normalized, err := normalizeDashboardPreferences(preferences)
 	if err != nil {
@@ -661,15 +775,20 @@ func (s *Store) run(actor *storeActor) {
 					item.resp <- queryResult{err: withStatus(400, "%v", err)}
 					continue
 				}
+				data, err := actor.loadAggregates(item.queryRange)
+				if err != nil {
+					item.resp <- queryResult{err: err}
+					continue
+				}
 				switch item.mode {
 				case statsQueryInitial:
-					item.resp <- queryResult{initial: buildInitialStatsForRange(actor.data, actor.since, actor.lastUsed, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)}
+					item.resp <- queryResult{initial: buildInitialStatsForRange(data, actor.since, actor.lastUsed, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)}
 				case statsQueryTrend:
-					item.resp <- queryResult{trend: buildStatsTrendForRange(actor.data, actor.since, item.queryRange, item.filter, now)}
+					item.resp <- queryResult{trend: buildStatsTrendForRange(data, actor.since, item.queryRange, item.filter, now)}
 				case statsQueryGroups:
-					item.resp <- queryResult{groups: buildGroupsForRange(actor.data, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)}
+					item.resp <- queryResult{groups: buildGroupsForRange(data, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)}
 				default:
-					stats := buildStatsForRangeWithFilter(actor.data, actor.since, actor.lastUsed, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)
+					stats := buildStatsForRangeWithFilter(data, actor.since, actor.lastUsed, item.queryRange, item.filter, now, actor.apiKeyCiphertexts)
 					item.resp <- queryResult{stats: stats}
 				}
 			case requestQueryCommand:
@@ -687,6 +806,10 @@ func (s *Store) run(actor *storeActor) {
 				preferences, err := actor.saveDashboardPreferences(item.preferences)
 				item.resp <- preferencesResult{preferences: preferences, err: err}
 			case labelQueryCommand:
+				if !actor.apiKeyCatalogHealthy {
+					item.resp <- labelQueryResult{err: withStatus(503, "API key catalog requires an explicit rebuild")}
+					continue
+				}
 				item.resp <- labelQueryResult{labels: cloneStringMap(actor.apiKeyLabels)}
 			case labelSetCommand:
 				item.resp <- actor.setAPIKeyLabel(item.hash, item.label)
@@ -707,7 +830,8 @@ func (s *Store) run(actor *storeActor) {
 					item.resp <- observedModelsResult{err: err}
 					continue
 				}
-				item.resp <- observedModelsResult{models: actor.observedModels(item.now)}
+				models, err := actor.observedModels(item.now)
+				item.resp <- observedModelsResult{models: models, err: err}
 			case costSnapshotCommand:
 				now := time.Now().UTC()
 				if err := actor.flush(now, true); err != nil {
@@ -770,6 +894,8 @@ func (s *Store) run(actor *storeActor) {
 				closeErr := actor.db.Close()
 				item.resp <- errors.Join(flushErr, closeErr)
 				return
+			case rebuildAPIKeyCatalogCommand:
+				item.resp <- actor.rebuildAPIKeyCatalog()
 			}
 		case now := <-ticker.C:
 			actor.lastFlushErr = actor.flush(now.UTC(), false)
@@ -781,6 +907,9 @@ func (a *storeActor) initialize() error {
 	now := time.Now().UTC()
 	var generations map[uint64]APIKeyCryptoGeneration
 	var activeGeneration uint64
+	var catalog map[string]apiKeyCatalogEntry
+	var observedModels map[string]uint64
+	var catalogHealthy = true
 	if err := a.db.Update(func(tx *bolt.Tx) error {
 		meta, err := tx.CreateBucketIfNotExists(metaBucket)
 		if err != nil {
@@ -798,6 +927,20 @@ func (a *storeActor) initialize() error {
 		if version > persistenceSchemaVersion {
 			return fmt.Errorf("unsupported database schema version %d", version)
 		}
+		if version >= persistenceSchemaVersion {
+			var err error
+			catalog, err = loadAPIKeyCatalog(meta)
+			if err != nil {
+				catalogHealthy = false
+				catalog = make(map[string]apiKeyCatalogEntry)
+			} else if len(meta.Get(apiKeyCatalogKey)) == 0 {
+				catalogHealthy = false
+			}
+			observedModels, err = loadObservedModels(meta)
+			if err != nil {
+				observedModels = nil
+			}
+		}
 		if err := migratePriceMetadata(meta, version); err != nil {
 			return err
 		}
@@ -815,10 +958,14 @@ func (a *storeActor) initialize() error {
 		if err := meta.Put(sinceKey, encodeInt64(since.UnixNano())); err != nil {
 			return err
 		}
-		if err := pruneHoursBucket(hours, cutoff); err != nil {
+		catalogForUpdate := catalog
+		if !catalogHealthy {
+			catalogForUpdate = nil
+		}
+		if err := pruneHoursBucketWithModels(hours, cutoff, catalogForUpdate, observedModels); err != nil {
 			return err
 		}
-		if err := pruneRequestsBucket(requests, time.Unix(cutoff, 0).UTC().UnixNano()); err != nil {
+		if err := pruneRequestsBucket(requests, time.Unix(cutoff, 0).UTC().UnixNano(), catalogForUpdate); err != nil {
 			return err
 		}
 		if err := migrateUsageSources(hours, requests, version); err != nil {
@@ -838,12 +985,40 @@ func (a *storeActor) initialize() error {
 		}
 		activeGeneration = activatedGeneration
 		generations = activatedGenerations
+		if version < persistenceSchemaVersion {
+			var err error
+			catalog, err = buildAPIKeyCatalog(hours, requests, generations)
+			if err != nil {
+				return err
+			}
+			catalogHealthy = true
+			if err := saveAPIKeyCatalog(meta, catalog); err != nil {
+				return err
+			}
+		} else if len(meta.Get(apiKeyCatalogKey)) == 0 {
+			catalogHealthy = false
+			catalog = make(map[string]apiKeyCatalogEntry)
+		}
+		if catalogHealthy {
+			if err := pruneAPIKeyLabelsToCatalog(meta, catalog); err != nil {
+				return err
+			}
+		}
+		if observedModels != nil {
+			if err := saveObservedModels(meta, observedModels); err != nil {
+				return err
+			}
+		}
 		return meta.Put(schemaKey, encodeUint64(persistenceSchemaVersion))
 	}); err != nil {
 		return fmt.Errorf("initialize database: %w", err)
 	}
 	a.generations = generations
 	a.activeGeneration = activeGeneration
+	a.apiKeyCatalog = catalog
+	a.apiKeyCatalogHealthy = catalogHealthy
+	a.observedModelCounts = observedModels
+	a.observedModelsReady = observedModels != nil
 
 	return a.reload()
 }
@@ -867,10 +1042,14 @@ func (a *storeActor) reload() error {
 	a.dashboardPreferences = defaultDashboardPreferences()
 	a.apiKeyCiphertexts = make(map[string]string)
 	a.apiKeyLabels = make(map[string]string)
+	a.apiKeyCatalog = make(map[string]apiKeyCatalogEntry)
+	a.persistedAggregates = make(map[aggregateKey]struct{})
+	a.observedModelCounts = make(map[string]uint64)
+	a.observedModelsReady = false
+	a.apiKeyCatalogHealthy = true
 	a.generations = make(map[uint64]APIKeyCryptoGeneration)
 	a.activeGeneration = 0
 
-	retainedHashes := make(map[string]struct{})
 	err := a.db.View(func(tx *bolt.Tx) error {
 		meta := tx.Bucket(metaBucket)
 		hours := tx.Bucket(hoursBucket)
@@ -885,9 +1064,6 @@ func (a *storeActor) reload() error {
 		if err != nil {
 			return err
 		}
-		if err := validateAPIKeyGenerationReferences(hours, requests, generations); err != nil {
-			return err
-		}
 		a.generations = generations
 		a.activeGeneration = findAPIKeyGeneration(generations, a.crypto)
 		a.since = time.Unix(0, decodeInt64(meta.Get(sinceKey))).UTC()
@@ -924,6 +1100,21 @@ func (a *storeActor) reload() error {
 			}
 			a.apiKeyLabels = cloneStringMap(labels)
 		}
+		catalog, err := loadAPIKeyCatalog(meta)
+		if err != nil {
+			// The catalog is derived state. Keep the primary aggregate/request data
+			// readable and disable catalog-dependent operations until a rebuild.
+			a.apiKeyCatalogHealthy = false
+			catalog = make(map[string]apiKeyCatalogEntry)
+		} else if len(meta.Get(apiKeyCatalogKey)) == 0 {
+			a.apiKeyCatalogHealthy = false
+		}
+		a.apiKeyCatalog = catalog
+		for ref, entry := range catalog {
+			if entry.Ciphertext != "" {
+				a.apiKeyCiphertexts[ref] = entry.Ciphertext
+			}
+		}
 		a.priceRevision = decodeUint64(meta.Get(modelPriceRevisionKey))
 		if a.priceRevision == 0 && len(a.modelPrices) > 0 {
 			a.priceRevision = 1
@@ -949,16 +1140,18 @@ func (a *storeActor) reload() error {
 		if raw := meta.Get(lastUsedKey); len(raw) > 0 {
 			a.lastUsed = time.Unix(0, decodeInt64(raw)).UTC()
 		}
-		if err := hours.ForEach(func(hourKey, value []byte) error {
+		hotStart := time.Now().UTC().Add(-aggregateHotWindow).Truncate(time.Minute).Unix()
+		cursor := hours.Cursor()
+		for hourKey, value := cursor.Seek(encodeInt64(hotStart)); hourKey != nil; hourKey, value = cursor.Next() {
 			if value != nil {
-				return nil
+				continue
 			}
 			hourBucket := hours.Bucket(hourKey)
 			if hourBucket == nil {
-				return nil
+				continue
 			}
 			hour := decodeInt64(hourKey)
-			return hourBucket.ForEach(func(dimensionKey, counterValue []byte) error {
+			if err := hourBucket.ForEach(func(dimensionKey, counterValue []byte) error {
 				var dimensions Dimensions
 				if err := json.Unmarshal(dimensionKey, &dimensions); err != nil {
 					return fmt.Errorf("decode dimensions: %w", err)
@@ -968,40 +1161,36 @@ func (a *storeActor) reload() error {
 					return fmt.Errorf("decode counters: %w", err)
 				}
 				a.data[aggregateKey{Hour: hour, Dimensions: dimensions}] = counters
-				if ref := apiKeyRef(dimensions.APIKeyGeneration, dimensions.APIKeyHash); ref != "" {
-					retainedHashes[ref] = struct{}{}
-				}
+				a.persistedAggregates[aggregateKey{Hour: hour, Dimensions: dimensions}] = struct{}{}
 				return nil
-			})
-		}); err != nil {
-			return err
-		}
-		return requests.ForEach(func(_, value []byte) error {
-			if value == nil {
-				return errors.New("request bucket contains nested bucket")
-			}
-			var request RequestDetail
-			if err := json.Unmarshal(value, &request); err != nil {
-				return fmt.Errorf("decode request detail: %w", err)
-			}
-			ref := apiKeyRef(request.APIKeyGeneration, request.APIKeyHash)
-			if ref != "" && request.APIKey != "" {
-				a.apiKeyCiphertexts[ref] = request.APIKey
-			}
-			if ref != "" {
-				retainedHashes[ref] = struct{}{}
+			}); err != nil {
+				return err
 			}
-			return nil
-		})
+		}
+		models, err := loadObservedModels(meta)
+		if err == nil {
+			a.observedModelCounts = models
+			a.observedModelsReady = true
+		}
+		return nil
 	})
 	if err != nil {
 		return err
 	}
-	for hash := range a.apiKeyLabels {
-		if _, retained := retainedHashes[hash]; !retained {
-			return fmt.Errorf("API key label references data outside retention: %s", hash)
+	for ref := range a.apiKeyLabels {
+		if !a.apiKeyCatalogHealthy {
+			break
+		}
+		entry, retained := a.apiKeyCatalog[ref]
+		if !retained || (entry.Hours == 0 && entry.Requests == 0) {
+			return fmt.Errorf("API key label references data outside retention: %s", ref)
 		}
 	}
+	if !a.observedModelsReady {
+		// A missing model index is valid legacy state. It is rebuilt lazily by
+		// ObservedModels so opening the database stays bounded by the hot window.
+		a.observedModelCounts = nil
+	}
 	return nil
 }
 
@@ -1119,6 +1308,205 @@ func saveAPIKeyGenerations(meta *bolt.Bucket, generations map[uint64]APIKeyCrypt
 	return nil
 }
 
+func cloneAPIKeyCatalog(values map[string]apiKeyCatalogEntry) map[string]apiKeyCatalogEntry {
+	cloned := make(map[string]apiKeyCatalogEntry, len(values))
+	for ref, entry := range values {
+		cloned[ref] = entry
+	}
+	return cloned
+}
+
+func loadAPIKeyCatalog(meta *bolt.Bucket) (map[string]apiKeyCatalogEntry, error) {
+	catalog := make(map[string]apiKeyCatalogEntry)
+	raw := meta.Get(apiKeyCatalogKey)
+	if len(raw) == 0 {
+		return catalog, nil
+	}
+	if err := json.Unmarshal(raw, &catalog); err != nil {
+		return nil, fmt.Errorf("decode API key catalog: %w", err)
+	}
+	for ref, entry := range catalog {
+		if _, _, ok := parseAPIKeyRef(ref); !ok {
+			return nil, fmt.Errorf("invalid API key catalog reference %q", ref)
+		}
+		if entry.Hours == 0 && entry.Requests == 0 {
+			return nil, fmt.Errorf("API key catalog reference %q has no retained data", ref)
+		}
+	}
+	return catalog, nil
+}
+
+func saveAPIKeyCatalog(meta *bolt.Bucket, catalog map[string]apiKeyCatalogEntry) error {
+	encoded, err := json.Marshal(catalog)
+	if err != nil {
+		return fmt.Errorf("encode API key catalog: %w", err)
+	}
+	return meta.Put(apiKeyCatalogKey, encoded)
+}
+
+func pruneAPIKeyLabelsToCatalog(meta *bolt.Bucket, catalog map[string]apiKeyCatalogEntry) error {
+	raw := meta.Get(apiKeyLabelsKey)
+	if len(raw) == 0 {
+		return nil
+	}
+	var labels map[string]string
+	if err := json.Unmarshal(raw, &labels); err != nil {
+		return fmt.Errorf("decode API key labels: %w", err)
+	}
+	if err := validateAPIKeyLabels(labels); err != nil {
+		return err
+	}
+	for ref := range labels {
+		entry, ok := catalog[ref]
+		if !ok || (entry.Hours == 0 && entry.Requests == 0) {
+			delete(labels, ref)
+		}
+	}
+	if len(labels) == 0 {
+		return meta.Delete(apiKeyLabelsKey)
+	}
+	encoded, err := json.Marshal(labels)
+	if err != nil {
+		return err
+	}
+	return meta.Put(apiKeyLabelsKey, encoded)
+}
+
+func updateAPIKeyCatalogEntry(catalog map[string]apiKeyCatalogEntry, dimensions Dimensions, source string, delta int) error {
+	ref := apiKeyRef(dimensions.APIKeyGeneration, dimensions.APIKeyHash)
+	if ref == "" {
+		if dimensions.APIKey != "" || dimensions.APIKeyHash != "" || dimensions.APIKeyGeneration != 0 {
+			return errors.New("API key catalog reference is invalid")
+		}
+		return nil
+	}
+	entry := catalog[ref]
+	switch source {
+	case "hours":
+		if delta > 0 {
+			entry.Hours += uint64(delta)
+		} else if entry.Hours < uint64(-delta) {
+			return fmt.Errorf("API key catalog hours count underflow for %s", ref)
+		} else {
+			entry.Hours -= uint64(-delta)
+		}
+	case "requests":
+		if delta > 0 {
+			entry.Requests += uint64(delta)
+		} else if entry.Requests < uint64(-delta) {
+			return fmt.Errorf("API key catalog request count underflow for %s", ref)
+		} else {
+			entry.Requests -= uint64(-delta)
+		}
+	default:
+		return fmt.Errorf("unknown API key catalog source %q", source)
+	}
+	if dimensions.APIKey != "" && (delta > 0 || entry.Ciphertext == "") {
+		entry.Ciphertext = dimensions.APIKey
+	}
+	if entry.Hours == 0 && entry.Requests == 0 {
+		delete(catalog, ref)
+	} else {
+		catalog[ref] = entry
+	}
+	return nil
+}
+
+func buildAPIKeyCatalog(hours, requests *bolt.Bucket, generations map[uint64]APIKeyCryptoGeneration) (map[string]apiKeyCatalogEntry, error) {
+	catalog := make(map[string]apiKeyCatalogEntry)
+	validate := func(dimensions Dimensions) error {
+		if err := validateAPIKeyDimensions(dimensions, generations); err != nil {
+			return err
+		}
+		return nil
+	}
+	if err := hours.ForEach(func(hourKey, value []byte) error {
+		if value != nil {
+			return nil
+		}
+		hour := hours.Bucket(hourKey)
+		if hour == nil {
+			return nil
+		}
+		return hour.ForEach(func(key, value []byte) error {
+			if value == nil {
+				return errors.New("hour bucket contains nested bucket")
+			}
+			var dimensions Dimensions
+			if err := json.Unmarshal(key, &dimensions); err != nil {
+				return fmt.Errorf("decode dimensions while building API key catalog: %w", err)
+			}
+			if err := validate(dimensions); err != nil {
+				return err
+			}
+			return updateAPIKeyCatalogEntry(catalog, dimensions, "hours", 1)
+		})
+	}); err != nil {
+		return nil, err
+	}
+	if err := requests.ForEach(func(_, value []byte) error {
+		if value == nil {
+			return errors.New("request bucket contains nested bucket")
+		}
+		var request RequestDetail
+		if err := json.Unmarshal(value, &request); err != nil {
+			return fmt.Errorf("decode request while building API key catalog: %w", err)
+		}
+		if err := validate(request.Dimensions); err != nil {
+			return err
+		}
+		return updateAPIKeyCatalogEntry(catalog, request.Dimensions, "requests", 1)
+	}); err != nil {
+		return nil, err
+	}
+	return catalog, nil
+}
+
+func (a *storeActor) rebuildAPIKeyCatalog() error {
+	var catalog map[string]apiKeyCatalogEntry
+	var ciphertexts map[string]string
+	err := a.db.Update(func(tx *bolt.Tx) error {
+		hours := tx.Bucket(hoursBucket)
+		requests := tx.Bucket(requestsBucket)
+		meta := tx.Bucket(metaBucket)
+		if hours == nil || requests == nil || meta == nil {
+			return errors.New("database buckets are missing")
+		}
+		var err error
+		catalog, err = buildAPIKeyCatalog(hours, requests, a.generations)
+		if err != nil {
+			return err
+		}
+		if err := saveAPIKeyCatalog(meta, catalog); err != nil {
+			return err
+		}
+		if err := pruneAPIKeyLabelsToCatalog(meta, catalog); err != nil {
+			return err
+		}
+		ciphertexts = make(map[string]string, len(catalog))
+		for ref, entry := range catalog {
+			if entry.Ciphertext != "" {
+				ciphertexts[ref] = entry.Ciphertext
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return fmt.Errorf("rebuild API key catalog: %w", err)
+	}
+	a.apiKeyCatalog = catalog
+	a.apiKeyCiphertexts = ciphertexts
+	labels := cloneStringMap(a.apiKeyLabels)
+	for ref := range labels {
+		if _, ok := catalog[ref]; !ok {
+			delete(labels, ref)
+		}
+	}
+	a.apiKeyLabels = labels
+	a.apiKeyCatalogHealthy = true
+	return nil
+}
+
 func findAPIKeyGeneration(generations map[uint64]APIKeyCryptoGeneration, crypto cryptoContext) uint64 {
 	if !crypto.enabled {
 		return 0
@@ -1176,11 +1564,7 @@ func activateAPIKeyGeneration(meta *bolt.Bucket, generations map[uint64]APIKeyCr
 
 func migrateAPIKeyCryptoSchema(meta, hours, requests *bolt.Bucket, version uint64, now time.Time) error {
 	if version >= 8 {
-		generations, err := loadAPIKeyGenerations(meta)
-		if err != nil {
-			return err
-		}
-		return validateAPIKeyGenerationReferences(hours, requests, generations)
+		return nil
 	}
 	hasData, err := databaseHasAPIKeyData(hours, requests)
 	if err != nil {
@@ -1242,7 +1626,7 @@ func migrateAPIKeyCryptoSchema(meta, hours, requests *bolt.Bucket, version uint6
 	if err := meta.Delete(apiKeyHashVersionKey); err != nil {
 		return err
 	}
-	return validateAPIKeyGenerationReferences(hours, requests, generations)
+	return nil
 }
 
 func migrateLegacyAPIKeyRecords(hours, requests *bolt.Bucket, generation uint64) error {
@@ -1328,22 +1712,26 @@ func migrateLegacyAPIKeyRecords(hours, requests *bolt.Bucket, generation uint64)
 	})
 }
 
-func validateAPIKeyGenerationReferences(hours, requests *bolt.Bucket, generations map[uint64]APIKeyCryptoGeneration) error {
-	validate := func(dimensions Dimensions) error {
-		if dimensions.APIKeyHash == "" {
-			if dimensions.APIKeyGeneration != 0 || dimensions.APIKey != "" {
-				return errors.New("API key generation or ciphertext exists without fingerprint")
-			}
-			return nil
-		}
-		if !validAPIKeyHash(dimensions.APIKeyHash) || dimensions.APIKeyGeneration == 0 {
-			return errors.New("API key fingerprint has no valid crypto generation")
-		}
-		if _, ok := generations[dimensions.APIKeyGeneration]; !ok {
-			return fmt.Errorf("API key references unknown crypto generation %d", dimensions.APIKeyGeneration)
+func validateAPIKeyDimensions(dimensions Dimensions, generations map[uint64]APIKeyCryptoGeneration) error {
+	if dimensions.APIKeyHash == "" {
+		if dimensions.APIKeyGeneration != 0 || dimensions.APIKey != "" {
+			return errors.New("API key generation or ciphertext exists without fingerprint")
 		}
 		return nil
 	}
+	if !validAPIKeyHash(dimensions.APIKeyHash) || dimensions.APIKeyGeneration == 0 {
+		return errors.New("API key fingerprint has no valid crypto generation")
+	}
+	if _, ok := generations[dimensions.APIKeyGeneration]; !ok {
+		return fmt.Errorf("API key references unknown crypto generation %d", dimensions.APIKeyGeneration)
+	}
+	return nil
+}
+
+func validateAPIKeyGenerationReferences(hours, requests *bolt.Bucket, generations map[uint64]APIKeyCryptoGeneration) error {
+	validate := func(dimensions Dimensions) error {
+		return validateAPIKeyDimensions(dimensions, generations)
+	}
 	if err := hours.ForEach(func(hourKey, value []byte) error {
 		if value != nil {
 			return nil
@@ -1436,6 +1824,9 @@ func (a *storeActor) hasRetainedAPIKeyRef(ref string) bool {
 }
 
 func (a *storeActor) resolveAPIKeyHash(hash string) (string, error) {
+	if !a.apiKeyCatalogHealthy {
+		return "", withStatus(503, "API key catalog requires an explicit rebuild")
+	}
 	if !validAPIKeyHash(hash) {
 		return "", withStatus(400, "api_key_hash must be 32 lowercase hexadecimal characters")
 	}
@@ -1480,6 +1871,9 @@ func (a *storeActor) saveAPIKeyLabels(labels map[string]string) error {
 }
 
 func (a *storeActor) setAPIKeyLabel(ref, label string) error {
+	if !a.apiKeyCatalogHealthy {
+		return withStatus(503, "API key catalog requires an explicit rebuild")
+	}
 	if err := validateAPIKeyLabel(ref, label); err != nil {
 		return withStatus(400, "%v", err)
 	}
@@ -1839,7 +2233,7 @@ func migrateUsageSources(hours, requests *bolt.Bucket, version uint64) error {
 		return RequestDetail{Sequence: request.Sequence, Time: request.Time, Dimensions: request.Dimensions, Counters: request.Counters, Result: request.Result, LatencyNS: request.LatencyNS, TTFTNS: request.TTFTNS, GenerationNS: request.GenerationNS, TPS: request.TPS, CacheHit: request.CacheHit, EstimatedCost: request.EstimatedCost}
 	}
 
-	if version >= persistenceSchemaVersion {
+	if version >= usageSourcesSchemaVersion {
 		return nil
 	}
 	if hours != nil {
@@ -2066,6 +2460,8 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 	}
 	var nextCiphertexts map[string]string
 	var nextLabels map[string]string
+	var nextCatalog map[string]apiKeyCatalogEntry
+	var nextObservedModels map[string]uint64
 	err := a.db.Update(func(tx *bolt.Tx) error {
 		meta := tx.Bucket(metaBucket)
 		hours := tx.Bucket(hoursBucket)
@@ -2073,6 +2469,22 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 		if meta == nil || hours == nil || requests == nil {
 			return errors.New("database buckets are missing")
 		}
+		catalog, err := loadAPIKeyCatalog(meta)
+		if err != nil {
+			if a.apiKeyCatalogHealthy {
+				return err
+			}
+			catalog = nil
+		}
+		if len(catalog) == 0 && len(a.apiKeyCatalog) > 0 {
+			catalog = cloneAPIKeyCatalog(a.apiKeyCatalog)
+		}
+		if a.observedModelsReady {
+			nextObservedModels = make(map[string]uint64, len(a.observedModelCounts))
+			for model, count := range a.observedModelCounts {
+				nextObservedModels[model] = count
+			}
+		}
 		for key := range a.dirty {
 			hourBucket, err := hours.CreateBucketIfNotExists(encodeInt64(key.Hour))
 			if err != nil {
@@ -2086,9 +2498,22 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 			if err != nil {
 				return err
 			}
+			existed := hourBucket.Get(dimensions) != nil
 			if err := hourBucket.Put(dimensions, counters); err != nil {
 				return err
 			}
+			if !existed {
+				if nextObservedModels != nil && key.Hour >= cutoff {
+					if err := updateObservedModelCount(nextObservedModels, key.Dimensions, 1); err != nil {
+						return err
+					}
+				}
+				if catalog != nil {
+					if err := updateAPIKeyCatalogEntry(catalog, key.Dimensions, "hours", 1); err != nil {
+						return err
+					}
+				}
+			}
 		}
 		for _, request := range a.pendingRequests {
 			encoded, err := json.Marshal(request)
@@ -2098,6 +2523,11 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 			if err := requests.Put(encodeRequestKey(request.Time.UnixNano(), request.Sequence), encoded); err != nil {
 				return err
 			}
+			if catalog != nil {
+				if err := updateAPIKeyCatalogEntry(catalog, request.Dimensions, "requests", 1); err != nil {
+					return err
+				}
+			}
 		}
 		if err := meta.Put(sinceKey, encodeInt64(nextSince.UnixNano())); err != nil {
 			return err
@@ -2111,35 +2541,54 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 			return err
 		}
 		if shouldPrune {
-			if err := pruneHoursBucket(hours, cutoff); err != nil {
-				return err
-			}
-			if err := pruneRequestsBucket(requests, time.Unix(cutoff, 0).UTC().UnixNano()); err != nil {
+			if err := pruneHoursBucketWithModels(hours, cutoff, catalog, nextObservedModels); err != nil {
 				return err
 			}
-			retained, ciphertexts, err := retainedAPIKeyState(hours, requests)
-			if err != nil {
+			if err := pruneRequestsBucket(requests, time.Unix(cutoff, 0).UTC().UnixNano(), catalog); err != nil {
 				return err
 			}
-			labels := cloneStringMap(a.apiKeyLabels)
-			for hash := range labels {
-				if _, ok := retained[hash]; !ok {
-					delete(labels, hash)
+			if catalog != nil {
+				ciphertexts := make(map[string]string, len(catalog))
+				for ref, entry := range catalog {
+					if entry.Hours > 0 || entry.Requests > 0 {
+						ciphertexts[ref] = entry.Ciphertext
+					}
+				}
+				labels := cloneStringMap(a.apiKeyLabels)
+				for ref := range labels {
+					entry, ok := catalog[ref]
+					if !ok || (entry.Hours == 0 && entry.Requests == 0) {
+						delete(labels, ref)
+					}
+				}
+				encoded, err := json.Marshal(labels)
+				if err != nil {
+					return err
 				}
+				if len(labels) == 0 {
+					if err := meta.Delete(apiKeyLabelsKey); err != nil {
+						return err
+					}
+				} else if err := meta.Put(apiKeyLabelsKey, encoded); err != nil {
+					return err
+				}
+				if err := saveAPIKeyCatalog(meta, catalog); err != nil {
+					return err
+				}
+				nextCiphertexts = ciphertexts
+				nextLabels = labels
+				nextCatalog = catalog
 			}
-			encoded, err := json.Marshal(labels)
-			if err != nil {
+		} else if catalog != nil && (len(a.pendingRequests) > 0 || len(a.dirty) > 0) {
+			if err := saveAPIKeyCatalog(meta, catalog); err != nil {
 				return err
 			}
-			if len(labels) == 0 {
-				if err := meta.Delete(apiKeyLabelsKey); err != nil {
-					return err
-				}
-			} else if err := meta.Put(apiKeyLabelsKey, encoded); err != nil {
+			nextCatalog = catalog
+		}
+		if nextObservedModels != nil {
+			if err := saveObservedModels(meta, nextObservedModels); err != nil {
 				return err
 			}
-			nextCiphertexts = ciphertexts
-			nextLabels = labels
 		}
 		return nil
 	})
@@ -2147,7 +2596,14 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 		return fmt.Errorf("flush database: %w", err)
 	}
 
+	dirtyKeys := make([]aggregateKey, 0, len(a.dirty))
+	for key := range a.dirty {
+		dirtyKeys = append(dirtyKeys, key)
+	}
 	clear(a.dirty)
+	for _, key := range dirtyKeys {
+		a.persistedAggregates[key] = struct{}{}
+	}
 	a.pendingRequests = a.pendingRequests[:0]
 	a.pending = 0
 	a.lastFlushErr = nil
@@ -2156,11 +2612,22 @@ func (a *storeActor) flush(now time.Time, force bool) error {
 		for key := range a.data {
 			if key.Hour < cutoff {
 				delete(a.data, key)
+				delete(a.persistedAggregates, key)
 			}
 		}
 		a.lastPruneAt = now
-		a.apiKeyCiphertexts = nextCiphertexts
-		a.apiKeyLabels = nextLabels
+		if nextCatalog != nil {
+			a.apiKeyCiphertexts = nextCiphertexts
+			a.apiKeyLabels = nextLabels
+			a.apiKeyCatalog = nextCatalog
+		}
+	}
+	if nextCatalog != nil && !shouldPrune {
+		a.apiKeyCatalog = nextCatalog
+	}
+	if nextObservedModels != nil {
+		a.observedModelCounts = nextObservedModels
+		a.observedModelsReady = true
 	}
 	return nil
 }
@@ -2204,6 +2671,13 @@ func (a *storeActor) reconfigure(config Config, crypto cryptoContext) error {
 }
 
 func (a *storeActor) saveDashboardPreferences(preferences DashboardPreferences) (DashboardPreferences, error) {
+	// Legacy clients omit this field; preserve it and prevent an older tab's
+	// delayed save from moving the most recent open time backwards.
+	previous, previousErr := time.Parse(time.RFC3339, a.dashboardPreferences.LastDashboardOpenAt)
+	next, nextErr := time.Parse(time.RFC3339, preferences.LastDashboardOpenAt)
+	if previousErr == nil && (nextErr != nil || next.Before(previous)) {
+		preferences.LastDashboardOpenAt = a.dashboardPreferences.LastDashboardOpenAt
+	}
 	encoded, err := json.Marshal(preferences)
 	if err != nil {
 		return DashboardPreferences{}, fmt.Errorf("encode dashboard preferences: %w", err)
@@ -2278,6 +2752,8 @@ func (a *storeActor) applyModelPriceSync(prices map[string]ModelPrice, settings
 			continue
 		}
 		if exists {
+			price.TimeZone = current.TimeZone
+			price.TimeTiers = cloneTimeTiers(current.TimeTiers)
 			metadata.Updated++
 		} else {
 			metadata.Created++
@@ -2348,15 +2824,18 @@ func (a *storeActor) persistPriceBook(prices map[string]ModelPrice, settings Pri
 	return nil
 }
 
-func (a *storeActor) observedModels(now time.Time) []string {
-	seen := make(map[string]struct{})
-	cutoff := retentionCutoff(a.config, now)
-	for key := range a.data {
-		if key.Hour < cutoff {
-			continue
+func (a *storeActor) observedModels(now time.Time) ([]string, error) {
+	if !a.observedModelsReady {
+		models, err := a.rebuildObservedModels()
+		if err != nil {
+			return nil, err
 		}
-		model := strings.TrimSpace(key.Dimensions.Model)
-		if model != "" {
+		a.observedModelCounts = models
+		a.observedModelsReady = true
+	}
+	seen := make(map[string]struct{}, len(a.observedModelCounts))
+	for model, count := range a.observedModelCounts {
+		if count > 0 && strings.TrimSpace(model) != "" {
 			seen[model] = struct{}{}
 		}
 	}
@@ -2365,7 +2844,30 @@ func (a *storeActor) observedModels(now time.Time) []string {
 		models = append(models, model)
 	}
 	sort.Strings(models)
-	return models
+	return models, nil
+}
+
+func (a *storeActor) rebuildObservedModels() (map[string]uint64, error) {
+	var models map[string]uint64
+	err := a.db.Update(func(tx *bolt.Tx) error {
+		hours := tx.Bucket(hoursBucket)
+		meta := tx.Bucket(metaBucket)
+		if hours == nil || meta == nil {
+			return errors.New("database buckets are missing")
+		}
+		var err error
+		models, err = buildObservedModels(hours, retentionCutoff(a.config, time.Now().UTC()))
+		if err != nil {
+			return err
+		}
+		return saveObservedModels(meta, models)
+	})
+	if err != nil {
+		return nil, fmt.Errorf("rebuild observed models: %w", err)
+	}
+	a.observedModelCounts = models
+	a.observedModelsReady = true
+	return models, nil
 }
 
 func (a *storeActor) reset() error {
@@ -2408,6 +2910,12 @@ func (a *storeActor) reset() error {
 		if err := meta.Delete(apiKeyLabelsKey); err != nil {
 			return err
 		}
+		if err := meta.Delete(apiKeyCatalogKey); err != nil {
+			return err
+		}
+		if err := meta.Delete(observedModelsKey); err != nil {
+			return err
+		}
 		return meta.Delete(lastUsedKey)
 	}); err != nil {
 		return fmt.Errorf("reset database: %w", err)
@@ -2422,6 +2930,11 @@ func (a *storeActor) reset() error {
 	a.lastUsed = time.Time{}
 	a.apiKeyCiphertexts = make(map[string]string)
 	a.apiKeyLabels = make(map[string]string)
+	a.apiKeyCatalog = make(map[string]apiKeyCatalogEntry)
+	a.persistedAggregates = make(map[aggregateKey]struct{})
+	a.observedModelCounts = make(map[string]uint64)
+	a.observedModelsReady = true
+	a.apiKeyCatalogHealthy = true
 	a.generations = make(map[uint64]APIKeyCryptoGeneration)
 	a.activeGeneration = 0
 	if a.crypto.enabled {
@@ -2514,6 +3027,77 @@ func (a *storeActor) queryRequests(queryRange usageRange, offset, limit int, mod
 	return page, nil
 }
 
+// loadAggregates returns the complete aggregate view for a range. Hot buckets
+// use the actor's in-memory state; cold buckets are read directly from bbolt.
+// Dirty keys always win over persisted values so unflushed records are not
+// lost or double-counted.
+func (a *storeActor) loadAggregates(queryRange usageRange) (map[aggregateKey]Counters, error) {
+	data := make(map[aggregateKey]Counters)
+	start := int64(0)
+	if !queryRange.Start.IsZero() {
+		start = queryRange.Start.UTC().Truncate(time.Minute).Unix()
+	}
+	end := int64(0)
+	if !queryRange.End.IsZero() {
+		end = queryRange.End.UTC().Truncate(time.Minute).Unix()
+	}
+	for key, counters := range a.data {
+		if key.Hour >= start && (end == 0 || key.Hour < end) {
+			data[key] = counters
+		}
+	}
+	err := a.db.View(func(tx *bolt.Tx) error {
+		hours := tx.Bucket(hoursBucket)
+		if hours == nil {
+			return errors.New("hours bucket is missing")
+		}
+		cursor := hours.Cursor()
+		key, value := cursor.First()
+		if !queryRange.Start.IsZero() {
+			key, value = cursor.Seek(encodeInt64(start))
+		}
+		for ; key != nil; key, value = cursor.Next() {
+			if value != nil {
+				continue
+			}
+			minute := decodeInt64(key)
+			if end != 0 && minute >= end {
+				break
+			}
+			bucket := hours.Bucket(key)
+			if bucket == nil {
+				continue
+			}
+			if err := bucket.ForEach(func(dimensionKey, counterValue []byte) error {
+				if counterValue == nil {
+					return errors.New("aggregate bucket contains nested bucket")
+				}
+				var dimensions Dimensions
+				if err := json.Unmarshal(dimensionKey, &dimensions); err != nil {
+					return fmt.Errorf("decode dimensions: %w", err)
+				}
+				aggregate := aggregateKey{Hour: minute, Dimensions: dimensions}
+				if _, dirty := a.dirty[aggregate]; dirty {
+					return nil
+				}
+				var counters Counters
+				if err := json.Unmarshal(counterValue, &counters); err != nil {
+					return fmt.Errorf("decode counters: %w", err)
+				}
+				data[aggregate] = counters
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+	if err != nil {
+		return nil, fmt.Errorf("load aggregate range: %w", err)
+	}
+	return data, nil
+}
+
 func requiresExactStats(queryRange usageRange) bool {
 	return queryRange.Name == "custom" &&
 		(queryRange.Start.Second() != 0 || queryRange.Start.Nanosecond() != 0 ||
@@ -2574,20 +3158,50 @@ func retentionCutoff(config Config, now time.Time) int64 {
 	return now.UTC().Add(-time.Duration(config.RetentionDays) * 24 * time.Hour).Truncate(time.Minute).Unix()
 }
 
-func pruneHoursBucket(hours *bolt.Bucket, cutoff int64) error {
-	var expired [][]byte
-	if err := hours.ForEach(func(key, value []byte) error {
-		if value == nil && decodeInt64(key) < cutoff {
-			expired = append(expired, append([]byte(nil), key...))
+func pruneHoursBucket(hours *bolt.Bucket, cutoff int64, catalog map[string]apiKeyCatalogEntry) error {
+	cursor := hours.Cursor()
+	for key, value := cursor.First(); key != nil; key, value = cursor.Next() {
+		if value != nil {
+			continue
 		}
-		return nil
-	}); err != nil {
+		if decodeInt64(key) >= cutoff {
+			break
+		}
+		hour := hours.Bucket(key)
+		if hour != nil && catalog != nil {
+			if err := hour.ForEach(func(dimensionKey, value []byte) error {
+				if value == nil {
+					return errors.New("hour bucket contains nested bucket")
+				}
+				var dimensions Dimensions
+				if err := json.Unmarshal(dimensionKey, &dimensions); err != nil {
+					return fmt.Errorf("decode dimensions while pruning API key catalog: %w", err)
+				}
+				return updateAPIKeyCatalogEntry(catalog, dimensions, "hours", -1)
+			}); err != nil {
+				return err
+			}
+		}
+		if err := hours.DeleteBucket(key); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func pruneHoursBucketWithModels(hours *bolt.Bucket, cutoff int64, catalog map[string]apiKeyCatalogEntry, models map[string]uint64) error {
+	if err := pruneHoursBucket(hours, cutoff, catalog); err != nil {
 		return err
 	}
-	for _, key := range expired {
-		if err := hours.DeleteBucket(key); err != nil {
+	if models != nil {
+		rebuilt, err := buildObservedModels(hours, cutoff)
+		if err != nil {
 			return err
 		}
+		clear(models)
+		for model, count := range rebuilt {
+			models[model] = count
+		}
 	}
 	return nil
 }
@@ -2599,7 +3213,7 @@ func encodeRequestKey(unixNano int64, sequence uint64) []byte {
 	return result
 }
 
-func pruneRequestsBucket(requests *bolt.Bucket, cutoffUnixNano int64) error {
+func pruneRequestsBucket(requests *bolt.Bucket, cutoffUnixNano int64, catalog map[string]apiKeyCatalogEntry) error {
 	cursor := requests.Cursor()
 	for key, _ := cursor.First(); key != nil; key, _ = cursor.Next() {
 		if len(key) != 16 {
@@ -2608,6 +3222,16 @@ func pruneRequestsBucket(requests *bolt.Bucket, cutoffUnixNano int64) error {
 		if decodeInt64(key[:8]) >= cutoffUnixNano {
 			break
 		}
+		if catalog != nil {
+			value := requests.Get(key)
+			var request RequestDetail
+			if err := json.Unmarshal(value, &request); err != nil {
+				return fmt.Errorf("decode request while pruning API key catalog: %w", err)
+			}
+			if err := updateAPIKeyCatalogEntry(catalog, request.Dimensions, "requests", -1); err != nil {
+				return err
+			}
+		}
 		if err := cursor.Delete(); err != nil {
 			return err
 		}
diff --git a/internal/plugin/persistence_test.go b/internal/plugin/persistence_test.go
index 20c4ccf..32f3853 100644
--- a/internal/plugin/persistence_test.go
+++ b/internal/plugin/persistence_test.go
@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"os"
 	"path/filepath"
+	"strings"
 	"sync"
 	"testing"
 	"time"
@@ -75,6 +76,273 @@ func TestStorePersistsAcrossRestartAndReset(t *testing.T) {
 	}
 }
 
+func TestStableSchemaReopenUsesAPIKeyCatalogWithoutDecodingRequests(t *testing.T) {
+	config := testConfig(t)
+	config.APIKeySecret = "catalog-reopen-secret-1234567890"
+	config.SyncOnRecord = true
+	crypto, err := deriveCryptoContext(config.APIKeySecret)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store, err := openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Record(encryptedUsageForTest(t, crypto, "catalog-client-key", "catalog-model", 7)); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := bolt.Open(config.DataPath, 0o600, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Update(func(tx *bolt.Tx) error {
+		requests := tx.Bucket(requestsBucket)
+		if requests == nil {
+			return errors.New("requests bucket is missing")
+		}
+		key, _ := requests.Cursor().First()
+		if key == nil {
+			return errors.New("request record is missing")
+		}
+		return requests.Put(key, []byte("not-json"))
+	}); err != nil {
+		_ = db.Close()
+		t.Fatal(err)
+	}
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	store, err = openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatalf("stable reopen decoded request records instead of using catalog: %v", err)
+	}
+	defer store.Close()
+	stats, err := store.Query("retention")
+	if err != nil || stats.Summary.Requests != 1 || len(stats.APIKeys) != 1 {
+		t.Fatalf("catalog-backed stats = %+v, %v", stats, err)
+	}
+}
+
+func TestSchemaNineAPIKeyCatalogBackfillsOnce(t *testing.T) {
+	config := testConfig(t)
+	config.APIKeySecret = "catalog-backfill-secret-12345678901234567890"
+	config.SyncOnRecord = true
+	crypto, err := deriveCryptoContext(config.APIKeySecret)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store, err := openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Record(encryptedUsageForTest(t, crypto, "backfill-client-key", "backfill-model", 3)); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err := bolt.Open(config.DataPath, 0o600, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Update(func(tx *bolt.Tx) error {
+		meta := tx.Bucket(metaBucket)
+		if meta == nil {
+			return errors.New("metadata bucket is missing")
+		}
+		if err := meta.Put(schemaKey, encodeUint64(9)); err != nil {
+			return err
+		}
+		return meta.Delete(apiKeyCatalogKey)
+	}); err != nil {
+		_ = db.Close()
+		t.Fatal(err)
+	}
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	store, err = openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatal(err)
+	}
+	stats, err := store.Query("retention")
+	if err != nil || stats.Summary.Requests != 1 || len(stats.APIKeys) != 1 {
+		t.Fatalf("backfilled catalog stats = %+v, %v", stats, err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	db, err = bolt.Open(config.DataPath, 0o600, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	if err := db.View(func(tx *bolt.Tx) error {
+		meta := tx.Bucket(metaBucket)
+		if got := decodeUint64(meta.Get(schemaKey)); got != persistenceSchemaVersion {
+			return fmt.Errorf("schema version = %d", got)
+		}
+		catalog, err := loadAPIKeyCatalog(meta)
+		if err != nil {
+			return err
+		}
+		if len(catalog) != 1 {
+			return fmt.Errorf("catalog entries = %d", len(catalog))
+		}
+		for _, entry := range catalog {
+			if entry.Requests != 1 || entry.Hours != 1 || entry.Ciphertext == "" {
+				return fmt.Errorf("catalog entry = %+v", entry)
+			}
+		}
+		return nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestStableSchemaMissingCatalogStaysDegradedUntilExplicitRebuild(t *testing.T) {
+	config := testConfig(t)
+	config.APIKeySecret = "catalog-missing-secret-12345678901234567890"
+	config.SyncOnRecord = true
+	crypto, err := deriveCryptoContext(config.APIKeySecret)
+	if err != nil {
+		t.Fatal(err)
+	}
+	store, err := openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatal(err)
+	}
+	usage := encryptedUsageForTest(t, crypto, "missing-catalog-key", "catalog-model", 3)
+	if err := store.Record(usage); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+	db, err := bolt.Open(config.DataPath, 0o600, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Update(func(tx *bolt.Tx) error { return tx.Bucket(metaBucket).Delete(apiKeyCatalogKey) }); err != nil {
+		_ = db.Close()
+		t.Fatal(err)
+	}
+	if err := db.Close(); err != nil {
+		t.Fatal(err)
+	}
+
+	store, err = openStoreWithCrypto(config, crypto)
+	if err != nil {
+		t.Fatal(err)
+	}
+	degradedStats, err := store.Query("retention")
+	if err != nil || degradedStats.Summary.Requests != 1 {
+		t.Fatalf("degraded catalog blocked primary stats: %+v, %v", degradedStats, err)
+	}
+	if _, err := store.ResolveAPIKeyHash(usage.Dimensions.APIKeyHash); err == nil {
+		t.Fatal("catalog-dependent resolve unexpectedly succeeded while degraded")
+	}
+	if err := store.RebuildAPIKeyCatalog(); err != nil {
+		t.Fatal(err)
+	}
+	if _, err := store.ResolveAPIKeyHash(usage.Dimensions.APIKeyHash); err != nil {
+		t.Fatalf("rebuilt catalog was not usable: %v", err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+}
+
+func TestStableSchemaReloadReadsColdAggregateRange(t *testing.T) {
+	config := testConfig(t)
+	config.RetentionDays = 3
+	config.SyncOnRecord = true
+	store, err := openStore(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	old := time.Now().UTC().Add(-48 * time.Hour)
+	if err := store.Record(normalizedUsage{Dimensions: Dimensions{Model: "cold-model"}, RequestedAt: old, Counters: Counters{Requests: 1, TotalTokens: 7}}); err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Close(); err != nil {
+		t.Fatal(err)
+	}
+	store, err = openStore(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+	stats, err := store.Query("retention")
+	if err != nil || stats.Summary.Requests != 1 || stats.Summary.TotalTokens != 7 {
+		t.Fatalf("cold aggregate was not loaded on demand: %+v, %v", stats.Summary, err)
+	}
+}
+
+func TestPruneRequestsBucketUpdatesCatalogWithoutScanningRetainedRecords(t *testing.T) {
+	db, err := bolt.Open(filepath.Join(t.TempDir(), "requests.db"), 0o600, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer db.Close()
+	hash := strings.Repeat("a", 32)
+	ref := apiKeyRef(1, hash)
+	now := time.Now().UTC()
+	expired := now.Add(-2 * time.Hour)
+	retained := now.Add(time.Hour)
+	request := RequestDetail{
+		Sequence: 1,
+		Time:     expired,
+		Dimensions: Dimensions{
+			APIKey:           "ciphertext",
+			APIKeyHash:       hash,
+			APIKeyGeneration: 1,
+		},
+	}
+	encoded, err := json.Marshal(request)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := db.Update(func(tx *bolt.Tx) error {
+		requests, err := tx.CreateBucket(requestsBucket)
+		if err != nil {
+			return err
+		}
+		if err := requests.Put(encodeRequestKey(expired.UnixNano(), 1), encoded); err != nil {
+			return err
+		}
+		return requests.Put(encodeRequestKey(retained.UnixNano(), 2), []byte("not-json"))
+	}); err != nil {
+		t.Fatal(err)
+	}
+	catalog := map[string]apiKeyCatalogEntry{ref: {Ciphertext: "ciphertext", Requests: 1}}
+	if err := db.Update(func(tx *bolt.Tx) error {
+		return pruneRequestsBucket(tx.Bucket(requestsBucket), now.UnixNano(), catalog)
+	}); err != nil {
+		t.Fatal(err)
+	}
+	if _, ok := catalog[ref]; ok {
+		t.Fatalf("expired request remained in catalog: %+v", catalog)
+	}
+	if err := db.View(func(tx *bolt.Tx) error {
+		requests := tx.Bucket(requestsBucket)
+		if requests.Get(encodeRequestKey(retained.UnixNano(), 2)) == nil {
+			return errors.New("retained request was deleted")
+		}
+		return nil
+	}); err != nil {
+		t.Fatal(err)
+	}
+}
+
 func TestExactCustomStatsUseRequestBoundariesAndSourceFilter(t *testing.T) {
 	config := testConfig(t)
 	config.SyncOnRecord = true
@@ -273,12 +541,13 @@ func TestDashboardPreferencesPersistAcrossRestartAndStatsReset(t *testing.T) {
 		TokenDisplayMode:       "B",
 		TimeRangeStart:         "2026-07-01",
 		TimeRangeEnd:           "2026-08-05",
+		LastDashboardOpenAt:    "2026-08-23T04:00:00Z",
 	}
 	saved, err := store.SaveDashboardPreferences(want)
 	if err != nil {
 		t.Fatal(err)
 	}
-	if saved.RequestPageSize != 50 || saved.DimensionPageSize != 200 || len(saved.HiddenRequestColumns) != 2 || saved.HiddenRequestColumns[0] != "model" || saved.HiddenRequestColumns[1] != "source" || saved.TokenDisplayMode != "B" || saved.TimeRangeStart != "2026-07-01" || saved.TimeRangeEnd != "2026-08-05" {
+	if saved.RequestPageSize != 50 || saved.DimensionPageSize != 200 || len(saved.HiddenRequestColumns) != 2 || saved.HiddenRequestColumns[0] != "model" || saved.HiddenRequestColumns[1] != "source" || saved.TokenDisplayMode != "B" || saved.TimeRangeStart != "2026-07-01" || saved.TimeRangeEnd != "2026-08-05" || saved.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
 		t.Fatalf("normalized preferences = %+v", saved)
 	}
 	if err := store.Close(); err != nil {
@@ -291,9 +560,20 @@ func TestDashboardPreferencesPersistAcrossRestartAndStatsReset(t *testing.T) {
 	}
 	defer store.Close()
 	loaded, err := store.QueryDashboardPreferences()
-	if err != nil || loaded.RequestPageSize != 50 || loaded.DimensionPageSize != 200 || len(loaded.HiddenDimensionColumns) != 1 || loaded.HiddenDimensionColumns[0] != "provider" || loaded.TimeRangeMode != "custom" || loaded.TokenDisplayMode != "B" || loaded.TimeRangeStart != "2026-07-01" {
+	if err != nil || loaded.RequestPageSize != 50 || loaded.DimensionPageSize != 200 || len(loaded.HiddenDimensionColumns) != 1 || loaded.HiddenDimensionColumns[0] != "provider" || loaded.TimeRangeMode != "custom" || loaded.TokenDisplayMode != "B" || loaded.TimeRangeStart != "2026-07-01" || loaded.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
 		t.Fatalf("preferences after restart = %+v, %v", loaded, err)
 	}
+	legacySave := loaded
+	legacySave.LastDashboardOpenAt = ""
+	legacySaved, err := store.SaveDashboardPreferences(legacySave)
+	if err != nil || legacySaved.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
+		t.Fatalf("legacy save cleared open time: %+v, %v", legacySaved, err)
+	}
+	legacySave.LastDashboardOpenAt = "2026-08-22T04:00:00Z"
+	legacySaved, err = store.SaveDashboardPreferences(legacySave)
+	if err != nil || legacySaved.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
+		t.Fatalf("delayed save moved open time backwards: %+v, %v", legacySaved, err)
+	}
 	if err := store.Reset(); err != nil {
 		t.Fatal(err)
 	}
diff --git a/internal/plugin/preferences.go b/internal/plugin/preferences.go
index 7a4fd62..990c627 100644
--- a/internal/plugin/preferences.go
+++ b/internal/plugin/preferences.go
@@ -29,6 +29,7 @@ type DashboardPreferences struct {
 	TokenDisplayMode       string   `json:"token_display_mode"`
 	TimeRangeStart         string   `json:"time_range_start,omitempty"`
 	TimeRangeEnd           string   `json:"time_range_end,omitempty"`
+	LastDashboardOpenAt    string   `json:"last_dashboard_open_at,omitempty"`
 }
 
 var requestColumnKeys = []string{
@@ -98,6 +99,12 @@ func normalizeDashboardPreferences(input DashboardPreferences) (DashboardPrefere
 		}
 		start, end = input.TimeRangeStart, input.TimeRangeEnd
 	}
+	lastDashboardOpenAt := ""
+	if input.LastDashboardOpenAt != "" {
+		if lastOpen, err := time.Parse(time.RFC3339, input.LastDashboardOpenAt); err == nil {
+			lastDashboardOpenAt = lastOpen.UTC().Format(time.RFC3339Nano)
+		}
+	}
 	return DashboardPreferences{
 		RequestPageSize:        input.RequestPageSize,
 		DimensionPageSize:      input.DimensionPageSize,
@@ -107,6 +114,7 @@ func normalizeDashboardPreferences(input DashboardPreferences) (DashboardPrefere
 		TokenDisplayMode:       tokenDisplayMode,
 		TimeRangeStart:         start,
 		TimeRangeEnd:           end,
+		LastDashboardOpenAt:    lastDashboardOpenAt,
 	}, nil
 }
 
diff --git a/internal/plugin/preferences_test.go b/internal/plugin/preferences_test.go
index 4f0ca9e..d8ebe16 100644
--- a/internal/plugin/preferences_test.go
+++ b/internal/plugin/preferences_test.go
@@ -42,3 +42,21 @@ func TestDashboardPreferencesNormalizeTokenDisplayMode(t *testing.T) {
 		t.Fatal("unsupported token display mode was accepted")
 	}
 }
+
+func TestDashboardPreferencesNormalizeLastDashboardOpenAt(t *testing.T) {
+	value := defaultDashboardPreferences()
+	value.LastDashboardOpenAt = "2026-08-23T12:00:00+08:00"
+	normalized, err := normalizeDashboardPreferences(value)
+	if err != nil {
+		t.Fatalf("last dashboard open time rejected: %v", err)
+	}
+	if normalized.LastDashboardOpenAt != "2026-08-23T04:00:00Z" {
+		t.Fatalf("normalized last dashboard open time = %q", normalized.LastDashboardOpenAt)
+	}
+
+	value.LastDashboardOpenAt = "not-a-time"
+	normalized, err = normalizeDashboardPreferences(value)
+	if err != nil || normalized.LastDashboardOpenAt != "" {
+		t.Fatalf("invalid last dashboard open time was not ignored: %+v, %v", normalized, err)
+	}
+}
diff --git a/internal/plugin/pricing.go b/internal/plugin/pricing.go
index 20b6b20..e2a0720 100644
--- a/internal/plugin/pricing.go
+++ b/internal/plugin/pricing.go
@@ -52,6 +52,9 @@ type ServiceTierPrice struct {
 
 // ModelPrice stores the active rates and optional synchronization provenance for one model.
 type ModelPrice struct {
+	timeLocation    *time.Location
+	TimeZone        string                      `json:"time_zone,omitempty"`
+	TimeTiers       []TimePriceTier             `json:"time_tiers,omitempty"`
 	Input           float64                     `json:"input"`
 	Output          float64                     `json:"output"`
 	CacheRead       float64                     `json:"cache_read"`
@@ -239,6 +242,9 @@ func normalizeModelPrice(model string, price ModelPrice) (ModelPrice, error) {
 		return ModelPrice{}, err
 	}
 	price.ContextTiers = tiers
+	if err := normalizeTimePricing(model, &price); err != nil {
+		return ModelPrice{}, err
+	}
 
 	if len(price.ServiceTiers) > maxServiceTierPrices {
 		return ModelPrice{}, fmt.Errorf("model %q must contain at most %d service tier prices", model, maxServiceTierPrices)
@@ -324,6 +330,9 @@ func tokenRatesZero(rates TokenRates) bool {
 }
 
 func sameEditableModelPrice(left, right ModelPrice) bool {
+	if !sameTimePricing(left, right) {
+		return false
+	}
 	if left.Input != right.Input || left.Output != right.Output || left.CacheRead != right.CacheRead || left.CacheCreation != right.CacheCreation || left.AccountingMode != right.AccountingMode || len(left.ContextTiers) != len(right.ContextTiers) || len(left.ServiceTiers) != len(right.ServiceTiers) {
 		return false
 	}
@@ -349,6 +358,7 @@ func sameEditableModelPrice(left, right ModelPrice) bool {
 func cloneModelPrices(input map[string]ModelPrice) map[string]ModelPrice {
 	result := make(map[string]ModelPrice, len(input))
 	for model, price := range input {
+		price.TimeTiers = cloneTimeTiers(price.TimeTiers)
 		price.ContextTiers = append([]ContextPriceTier(nil), price.ContextTiers...)
 		if len(price.ServiceTiers) > 0 {
 			price.ServiceTiers = make(map[string]ServiceTierPrice, len(price.ServiceTiers))
diff --git a/internal/plugin/time_pricing.go b/internal/plugin/time_pricing.go
new file mode 100644
index 0000000..82b830f
--- /dev/null
+++ b/internal/plugin/time_pricing.go
@@ -0,0 +1,164 @@
+package plugin
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+	"time"
+	_ "time/tzdata" // Keep named zones available in Windows and minimal containers.
+)
+
+const maxTimePriceTiers = 32
+
+// TimePriceTier repeats weekly. Days use ISO weekdays; empty means every day.
+// Overnight windows belong to their starting day. End is exclusive.
+type TimePriceTier struct {
+	Name  string `json:"name"`
+	Days  []int  `json:"days,omitempty"`
+	Start string `json:"start"`
+	End   string `json:"end"`
+	TokenRates
+}
+
+func clockMinute(value string) (int, error) {
+	parsed, err := time.Parse("15:04", value)
+	if err != nil || parsed.Format("15:04") != value {
+		return 0, fmt.Errorf("invalid time %q: use HH:mm", value)
+	}
+	return parsed.Hour()*60 + parsed.Minute(), nil
+}
+
+func timeTierDays(tier TimePriceTier) []int {
+	if len(tier.Days) == 0 {
+		return []int{1, 2, 3, 4, 5, 6, 7}
+	}
+	return tier.Days
+}
+
+func normalizeTimePricing(model string, price *ModelPrice) error {
+	price.TimeZone = strings.TrimSpace(price.TimeZone)
+	if len(price.TimeTiers) > maxTimePriceTiers {
+		return fmt.Errorf("model %q: at most %d time tiers", model, maxTimePriceTiers)
+	}
+	if price.TimeZone == "" && len(price.TimeTiers) > 0 {
+		price.TimeZone = "UTC"
+	}
+	if price.TimeZone != "" {
+		if price.TimeZone == "Local" {
+			return fmt.Errorf("model %q: use an explicit time zone", model)
+		}
+		if _, err := time.LoadLocation(price.TimeZone); err != nil {
+			return fmt.Errorf("model %q: invalid time zone %q", model, price.TimeZone)
+		}
+	}
+	price.TimeTiers = cloneTimeTiers(price.TimeTiers)
+	var occupied [7 * 1440]bool
+	names := map[string]bool{}
+	for i := range price.TimeTiers {
+		tier := &price.TimeTiers[i]
+		tier.Name = strings.TrimSpace(tier.Name)
+		if tier.Name == "" || !validOptionalDimension(tier.Name) || names[tier.Name] {
+			return fmt.Errorf("model %q: time tier names must be nonempty and unique", model)
+		}
+		names[tier.Name] = true
+		start, err := clockMinute(tier.Start)
+		if err != nil {
+			return err
+		}
+		end, err := clockMinute(tier.End)
+		if err != nil {
+			return err
+		}
+		if start == end {
+			return fmt.Errorf("model %q: time tier start and end must differ", model)
+		}
+		if err := validateTokenRates(tier.TokenRates, model, "time tier "+tier.Name); err != nil {
+			return err
+		}
+		sort.Ints(tier.Days)
+		for j, day := range tier.Days {
+			if day < 1 || day > 7 || (j > 0 && tier.Days[j-1] == day) {
+				return fmt.Errorf("model %q: days must be unique integers from 1 to 7", model)
+			}
+		}
+		duration := (end - start + 1440) % 1440
+		for _, day := range timeTierDays(*tier) {
+			for minute := 0; minute < duration; minute++ {
+				index := ((day-1)*1440 + start + minute) % len(occupied)
+				if occupied[index] {
+					return fmt.Errorf("model %q: overlapping time tiers", model)
+				}
+				occupied[index] = true
+			}
+		}
+	}
+	return nil
+}
+
+func cloneTimeTiers(tiers []TimePriceTier) []TimePriceTier {
+	result := append([]TimePriceTier(nil), tiers...)
+	for i := range result {
+		result[i].Days = append([]int(nil), result[i].Days...)
+	}
+	return result
+}
+func sameTimePricing(a, b ModelPrice) bool {
+	return a.TimeZone == b.TimeZone && reflect.DeepEqual(a.TimeTiers, b.TimeTiers)
+}
+
+// Match wall-clock time in the configured zone, including repeated DST hours.
+func selectTimePriceTier(price ModelPrice, requestedAt time.Time) (TimePriceTier, bool) {
+	if len(price.TimeTiers) == 0 || requestedAt.IsZero() {
+		return TimePriceTier{}, false
+	}
+	zone := price.TimeZone
+	if zone == "" {
+		zone = "UTC"
+	}
+	if zone == "Local" {
+		return TimePriceTier{}, false
+	}
+	location := price.timeLocation
+	var err error
+	if location == nil {
+		location, err = time.LoadLocation(zone)
+	}
+	if err != nil {
+		return TimePriceTier{}, false
+	}
+	local := requestedAt.In(location)
+	day := (int(local.Weekday())+6)%7 + 1
+	minute := local.Hour()*60 + local.Minute()
+	var matched TimePriceTier
+	found := false
+	for _, tier := range price.TimeTiers {
+		start, e1 := clockMinute(tier.Start)
+		end, e2 := clockMinute(tier.End)
+		if e1 != nil || e2 != nil || start == end {
+			return TimePriceTier{}, false
+		}
+		matchDay := day
+		hit := minute >= start && minute < end
+		if start > end {
+			hit = minute >= start || minute < end
+			if minute < end {
+				matchDay = (day+5)%7 + 1
+			}
+		}
+		if !hit {
+			continue
+		}
+		for _, allowed := range timeTierDays(tier) {
+			if allowed == matchDay {
+				if found {
+					return TimePriceTier{}, false
+				}
+				matched = tier
+				found = true
+				break
+			}
+		}
+	}
+	return matched, found
+}
diff --git a/internal/plugin/time_pricing_integration_test.go b/internal/plugin/time_pricing_integration_test.go
new file mode 100644
index 0000000..e854254
--- /dev/null
+++ b/internal/plugin/time_pricing_integration_test.go
@@ -0,0 +1,57 @@
+package plugin
+
+import (
+	"encoding/json"
+	"github.com/router-for-me/CLIProxyAPI/v7/sdk/pluginapi"
+	"net/http"
+	"testing"
+)
+
+func TestTimePricingSaveAPI(t *testing.T) {
+	store, err := openStore(testConfig(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+	runtime := &pluginRuntime{store: store}
+	for _, valid := range []bool{true, false} {
+		p := nightPrice()
+		if !valid {
+			p.TimeZone = "invalid/zone"
+		}
+		body, _ := json.Marshal(map[string]any{"prices": map[string]ModelPrice{"m": p}})
+		response, err := runtime.savePricesResponse(pluginapi.ManagementRequest{Body: body, Headers: http.Header{"Content-Type": []string{"application/json"}}})
+		want := http.StatusOK
+		if !valid {
+			want = http.StatusBadRequest
+		}
+		if err != nil || response.StatusCode != want {
+			t.Fatalf("status=%d want=%d err=%v body=%s", response.StatusCode, want, err, response.Body)
+		}
+	}
+	book, err := store.QueryPriceBook()
+	if err != nil || book.Prices["m"].TimeZone != "Asia/Shanghai" {
+		t.Fatal(book, err)
+	}
+}
+func TestTimePricingSyncPreservesCatalogSchedule(t *testing.T) {
+	store, err := openStore(testConfig(t))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer store.Close()
+	book, err := store.QueryPriceBook()
+	if err != nil {
+		t.Fatal(err)
+	}
+	p := nightPrice()
+	p.Source = priceSourceModelsDev
+	book, err = store.ApplyModelPriceSync(map[string]ModelPrice{"m": p}, book.SyncSettings, PriceSyncMetadata{}, book.Revision)
+	if err != nil {
+		t.Fatal(err)
+	}
+	book, err = store.ApplyModelPriceSync(map[string]ModelPrice{"m": {Input: 9, Source: priceSourceModelsDev}}, book.SyncSettings, PriceSyncMetadata{}, book.Revision)
+	if err != nil || book.Prices["m"].Input != 9 || len(book.Prices["m"].TimeTiers) != 1 || book.Prices["m"].TimeZone != "Asia/Shanghai" {
+		t.Fatal(book, err)
+	}
+}
diff --git a/internal/plugin/time_pricing_test.go b/internal/plugin/time_pricing_test.go
new file mode 100644
index 0000000..2266237
--- /dev/null
+++ b/internal/plugin/time_pricing_test.go
@@ -0,0 +1,153 @@
+package plugin
+
+import (
+	"math"
+	"testing"
+	"time"
+)
+
+func nightPrice() ModelPrice {
+	return ModelPrice{Input: 4, TimeZone: "Asia/Shanghai", TimeTiers: []TimePriceTier{{Name: "night", Days: []int{1}, Start: "23:00", End: "08:00", TokenRates: TokenRates{Input: 1, Output: 2, CacheRead: 0.5, CacheCreation: 0.25}}}}
+}
+func TestTimePricingBoundaries(t *testing.T) {
+	price := nightPrice()
+	for _, tc := range []struct {
+		stamp string
+		hit   bool
+	}{
+		{"2026-09-14T22:59:59+08:00", false}, {"2026-09-14T23:00:00+08:00", true},
+		{"2026-09-15T07:59:59+08:00", true}, {"2026-09-15T08:00:00+08:00", false},
+		{"2026-09-16T02:00:00+08:00", false},
+	} {
+		stamp, _ := time.Parse(time.RFC3339, tc.stamp)
+		_, hit := selectTimePriceTier(price, stamp)
+		if hit != tc.hit {
+			t.Errorf("%s hit=%v", tc.stamp, hit)
+		}
+	}
+	price.TimeTiers[0].Days = []int{7}
+	stamp, _ := time.Parse(time.RFC3339, "2026-09-14T02:00:00+08:00")
+	if _, hit := selectTimePriceTier(price, stamp); !hit {
+		t.Fatal("Sunday overnight must include Monday morning")
+	}
+	price.TimeZone = "America/Los_Angeles"
+	price.TimeTiers[0].Days = nil
+	price.TimeTiers[0].Start = "01:00"
+	price.TimeTiers[0].End = "02:00"
+	for _, s := range []string{"2026-11-01T08:30:00Z", "2026-11-01T09:30:00Z"} {
+		stamp, _ := time.Parse(time.RFC3339, s)
+		if _, hit := selectTimePriceTier(price, stamp); !hit {
+			t.Fatal("DST repeated hour", s)
+		}
+	}
+}
+func TestTimePricingValidation(t *testing.T) {
+	for name, mutate := range map[string]func(*ModelPrice){
+		"zone": func(p *ModelPrice) { p.TimeZone = "bad/zone" }, "local": func(p *ModelPrice) { p.TimeZone = "Local" },
+		"clock": func(p *ModelPrice) { p.TimeTiers[0].Start = "24:00" }, "equal": func(p *ModelPrice) { p.TimeTiers[0].End = "23:00" },
+		"day": func(p *ModelPrice) { p.TimeTiers[0].Days = []int{0} }, "duplicate day": func(p *ModelPrice) { p.TimeTiers[0].Days = []int{1, 1} },
+		"rate": func(p *ModelPrice) { p.TimeTiers[0].Input = math.NaN() },
+		"overlap": func(p *ModelPrice) {
+			p.TimeTiers = append(p.TimeTiers, TimePriceTier{Name: "next", Days: []int{2}, Start: "07:00", End: "09:00"})
+		},
+	} {
+		t.Run(name, func(t *testing.T) {
+			p := nightPrice()
+			mutate(&p)
+			if _, err := normalizeModelPrice("m", p); err == nil {
+				t.Fatal("accepted invalid config")
+			}
+		})
+	}
+	p := nightPrice()
+	p.TimeZone = ""
+	normalized, err := normalizeModelPrice("m", p)
+	if err != nil || normalized.TimeZone != "UTC" {
+		t.Fatal(normalized, err)
+	}
+	copy := cloneModelPrices(map[string]ModelPrice{"m": p})
+	v := copy["m"]
+	v.TimeTiers[0].Days[0] = 2
+	if p.TimeTiers[0].Days[0] != 1 || sameEditableModelPrice(p, v) {
+		t.Fatal("copy/equality ignores days")
+	}
+}
+func TestTimePricingCostPrecedence(t *testing.T) {
+	p := nightPrice()
+	p.ServiceTiers = map[string]ServiceTierPrice{"priority": {Input: 10, ContextTiers: []ContextPriceTier{{Threshold: 2000000, Input: 20}}}}
+	stamp, _ := time.Parse(time.RFC3339, "2026-09-14T23:00:00+08:00")
+	req := RequestDetail{Time: stamp, Dimensions: Dimensions{Model: "m", ServiceTier: "priority"}, Counters: Counters{InputTokens: 1000000}}
+	cost := estimateRequestCost(req, map[string]ModelPrice{"m": p})
+	if cost.TotalUSD != 1 || cost.PriceTimeTier != "night" {
+		t.Fatal(cost)
+	}
+	req.InputTokens = 3000000
+	cost = estimateRequestCost(req, map[string]ModelPrice{"m": p})
+	if cost.TotalUSD != 60 || cost.PriceTimeTier != "" {
+		t.Fatal(cost)
+	}
+	req.Time = stamp.Add(12 * time.Hour)
+	req.InputTokens = 1000000
+	cost = estimateRequestCost(req, map[string]ModelPrice{"m": p})
+	if cost.TotalUSD != 10 {
+		t.Fatal(cost)
+	}
+}
+func TestTimePricingPersistenceSyncAndCache(t *testing.T) {
+	config := testConfig(t)
+	config.SyncOnRecord = true
+	store, err := openStore(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer func() { store.Close() }()
+	now := time.Now().UTC()
+	p := nightPrice()
+	p.TimeZone = "UTC"
+	p.TimeTiers[0].Days = nil
+	// This one-minute window always contains the recorded instant, including midnight.
+	p.TimeTiers[0].Start = now.Format("15:04")
+	p.TimeTiers[0].End = now.Add(time.Minute).Format("15:04")
+	book, err := store.SavePriceBook(map[string]ModelPrice{"m": p}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := store.Record(normalizedUsage{RequestedAt: now, Dimensions: Dimensions{Model: "m"}, Counters: Counters{Requests: 1, InputTokens: 1000000}}); err != nil {
+		t.Fatal(err)
+	}
+	costs, err := store.QueryCosts("24h")
+	if err != nil || costs.Summary.TotalUSD != 1 {
+		t.Fatal(costs, err)
+	}
+	p.TimeTiers[0].Input = 2
+	book, err = store.SavePriceBook(map[string]ModelPrice{"m": p}, nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	costs, err = store.QueryCosts("24h")
+	if err != nil || costs.Summary.TotalUSD != 2 {
+		t.Fatal(costs, err)
+	}
+	book, err = store.ApplyModelPriceSync(map[string]ModelPrice{"m": {Input: 99, Source: priceSourceModelsDev}}, book.SyncSettings, PriceSyncMetadata{}, book.Revision)
+	if err != nil || book.Prices["m"].TimeTiers[0].Input != 2 || book.LastSync.SkippedManual != 1 {
+		t.Fatal(book, err)
+	}
+	backup, backupErr := store.Backup()
+	if backupErr != nil {
+		t.Fatal(backupErr)
+	}
+	if err := store.RestoreBackup(backup); err != nil {
+		t.Fatal(err)
+	}
+	if err = store.Close(); err != nil {
+		t.Fatal(err)
+	}
+	store, err = openStore(config)
+	if err != nil {
+		t.Fatal(err)
+	}
+	book, err = store.QueryPriceBook()
+	if err != nil || book.Prices["m"].TimeZone != "UTC" || len(book.Prices["m"].TimeTiers) != 1 {
+		t.Fatal(book, err)
+	}
+}
diff --git a/test/dashboard_date_range.mjs b/test/dashboard_date_range.mjs
index c8dde4b..d1ebaf0 100644
--- a/test/dashboard_date_range.mjs
+++ b/test/dashboard_date_range.mjs
@@ -4,9 +4,9 @@ import { chromium } from 'playwright-core';
 
 const [htmlPath, chromePath, scenario = 'exclusive'] = process.argv.slice(2);
 if (!htmlPath || !chromePath) {
-  throw new Error('usage: node test/dashboard_date_range.mjs <dashboard-html-path> <google-chrome-path> [exclusive|end-time|end-time-reset|quick-preset|reverse|los-angeles-dst|token-unit]');
+  throw new Error('usage: node test/dashboard_date_range.mjs <dashboard-html-path> <google-chrome-path> [exclusive|end-time|end-time-reset|quick-preset|reverse|los-angeles-dst|token-unit|recent-open|expired-open]');
 }
-if (!['exclusive', 'end-time', 'end-time-reset', 'quick-preset', 'reverse', 'los-angeles-dst', 'token-unit'].includes(scenario)) {
+if (!['exclusive', 'end-time', 'end-time-reset', 'quick-preset', 'reverse', 'los-angeles-dst', 'token-unit', 'recent-open', 'expired-open'].includes(scenario)) {
   throw new Error(`unknown dashboard date-range browser scenario: ${scenario}`);
 }
 
@@ -15,6 +15,8 @@ const resourceBase = '/v0/resource/plugins/calendar-browser-test';
 const timezoneId = scenario === 'los-angeles-dst' ? 'America/Los_Angeles' : 'UTC';
 const initialRange = scenario === 'los-angeles-dst'
   ? { start: '2026-08-23T07:00:00.000Z', end: '2026-08-24T07:00:00.000Z' }
+  : ['recent-open', 'expired-open'].includes(scenario)
+  ? { start: '2026-08-20T01:02:03.000Z', end: '2026-08-21T04:05:06.000Z' }
   : { start: '2026-08-23T00:00:00.000Z', end: '2026-08-24T00:00:00.000Z' };
 const emptyInitial = {
   generated_at: '2026-08-23T00:00:00.000Z',
@@ -32,6 +34,15 @@ const tokenUnitInitial = {
 };
 const initialPayload = scenario === 'token-unit' ? tokenUnitInitial : emptyInitial;
 const savedTokenDisplayModes = [];
+const initialStatsURLs = [];
+let persistedPreferences = {
+  time_range_mode: 'custom', time_range_start: initialRange.start, time_range_end: initialRange.end,
+  request_page_size: 25, dimension_page_size: 50,
+  hidden_request_columns: ['model'], hidden_dimension_columns: ['provider'],
+  token_display_mode: scenario === 'token-unit' ? 'B' : 'full',
+  last_dashboard_open_at: scenario === 'recent-open' ? '2026-08-23T11:50:00.000Z'
+    : scenario === 'expired-open' ? '2026-08-23T11:44:00.000Z' : '',
+};
 
 async function setTimePickerValue(page, boundary, values) {
   for (const [part, value] of Object.entries(values)) {
@@ -57,23 +68,25 @@ const server = createServer((request, response) => {
   if (url.pathname === `${resourceBase}/preferences`) {
     if (url.searchParams.get('save') === '1') {
       savedTokenDisplayModes.push(url.searchParams.get('token_display_mode'));
-      sendJSON({
+      persistedPreferences = {
         request_page_size: url.searchParams.get('request_page_size'),
         dimension_page_size: url.searchParams.get('dimension_page_size'),
         time_range_mode: url.searchParams.get('time_range_mode'),
         token_display_mode: url.searchParams.get('token_display_mode'),
-      });
+        last_dashboard_open_at: url.searchParams.get('last_dashboard_open_at'),
+        time_range_start: url.searchParams.get('time_range_start'),
+        time_range_end: url.searchParams.get('time_range_end'),
+        hidden_request_columns: url.searchParams.getAll('hidden_request_column'),
+        hidden_dimension_columns: url.searchParams.getAll('hidden_dimension_column'),
+      };
+      sendJSON(persistedPreferences);
       return;
     }
-    sendJSON({
-      time_range_mode: 'custom',
-      time_range_start: initialRange.start,
-      time_range_end: initialRange.end,
-      token_display_mode: scenario === 'token-unit' ? 'B' : 'full',
-    });
+    sendJSON(persistedPreferences);
     return;
   }
   if (url.pathname === `${resourceBase}/stats/initial`) {
+    initialStatsURLs.push(url.toString());
     sendJSON(initialPayload);
     return;
   }
@@ -141,7 +154,8 @@ try {
         tokenButton.click(),
       ]);
     }
-    if (JSON.stringify(savedTokenDisplayModes) !== JSON.stringify(['full', 'k', 'm', 'B'])) {
+    const toggledModes = savedTokenDisplayModes.slice(-4);
+    if (JSON.stringify(toggledModes) !== JSON.stringify(['full', 'k', 'm', 'B'])) {
       throw new Error(`expected saved token display modes full,k,m,B, got ${savedTokenDisplayModes.join(',')}`);
     }
     if (await tokenButton.textContent() !== 'B' || await totalTokens.textContent() !== '1.23B') {
@@ -149,6 +163,33 @@ try {
     }
   }
 
+  if (scenario === 'recent-open' || scenario === 'expired-open') {
+    const initialURL = new URL(initialStatsURLs[0]);
+    const expectedStart = scenario === 'expired-open'
+      ? '2026-08-23T00:00:00.000Z'
+      : initialRange.start;
+    const expectedEnd = scenario === 'expired-open'
+      ? '2026-08-24T00:00:00.000Z'
+      : initialRange.end;
+    if (initialURL.searchParams.get('start') !== expectedStart || initialURL.searchParams.get('end') !== expectedEnd) {
+      throw new Error(`expected ${scenario} initial range ${expectedStart}..${expectedEnd}, got ${initialURL.searchParams.get('start')}..${initialURL.searchParams.get('end')}`);
+    }
+    if (persistedPreferences.time_range_start !== expectedStart || persistedPreferences.time_range_end !== expectedEnd
+      || !persistedPreferences.last_dashboard_open_at.startsWith('2026-08-23T12:00:00.')
+      || persistedPreferences.request_page_size !== '25' || persistedPreferences.dimension_page_size !== '50'
+      || persistedPreferences.hidden_request_columns.join(',') !== 'model'
+      || persistedPreferences.hidden_dimension_columns.join(',') !== 'provider') {
+      throw new Error(`incorrect persisted open state: ${JSON.stringify(persistedPreferences)}`);
+    }
+    const reloaded = page.waitForResponse(response => new URL(response.url()).pathname === `${resourceBase}/stats/initial`);
+    await page.reload();
+    const reloadedURL = new URL((await reloaded).url());
+    if (reloadedURL.searchParams.get('start') !== expectedStart || reloadedURL.searchParams.get('end') !== expectedEnd) {
+      throw new Error(`saved range lost on reload: ${reloadedURL}`);
+    }
+  }
+
+  if (!['recent-open', 'expired-open'].includes(scenario)) {
   await page.locator('#rangeButton').click();
   if (scenario === 'quick-preset') {
     await page.locator('[data-range-preset="last_30_days"]').click();
@@ -270,6 +311,7 @@ try {
       throw new Error(`expected reverse-selection end=2026-08-24T00:00:00.000Z, got ${confirmed.searchParams.get('end')}`);
     }
   }
+  }
   if (pageErrors.length) {
     throw pageErrors[0];
   }
diff --git a/test/dashboard_time_pricing.mjs b/test/dashboard_time_pricing.mjs
new file mode 100644
index 0000000..d08f4c9
--- /dev/null
+++ b/test/dashboard_time_pricing.mjs
@@ -0,0 +1,122 @@
+import { createServer } from 'node:http';
+import { readFile } from 'node:fs/promises';
+import { chromium } from 'playwright-core';
+
+const [htmlPath, chromePath] = process.argv.slice(2);
+if (!htmlPath || !chromePath) {
+  throw new Error('usage: node test/dashboard_api_key_layout.mjs <dashboard-html-path> <google-chrome-path>');
+}
+
+const dashboardHTML = await readFile(htmlPath, 'utf8');
+let savedPrices = {m:{input:4,output:8}};
+let revision = 1, saves = 0;
+let chunks = [];
+const resourceBase = '/v0/resource/plugins/api-key-layout-browser-test';
+const server = createServer((request, response) => {
+  const url = new URL(request.url, 'http://127.0.0.1');
+  const sendJSON = (value) => {
+    response.writeHead(200, { 'content-type': 'application/json' });
+    response.end(JSON.stringify(value));
+  };
+
+  if (url.pathname === `${resourceBase}/full-mode/prices/save`) {
+    if (url.searchParams.get('stage') === 'begin') { chunks = []; sendJSON({upload:'test-upload'}); return; }
+    if (url.searchParams.get('stage') === 'chunk') { chunks[Number(url.searchParams.get('index'))] = request.headers['x-full-mode-payload']; sendJSON({}); return; }
+    if (url.searchParams.get('stage') === 'commit') {
+      savedPrices = JSON.parse(Buffer.from(chunks.join(''), 'base64url').toString('utf8')).prices;
+      revision++; saves++; sendJSON({prices:savedPrices, revision}); return;
+    }
+  }
+  if (url.pathname === `${resourceBase}/dashboard`) {
+    response.writeHead(200, { 'content-type': 'text/html; charset=utf-8' });
+    response.end(dashboardHTML);
+    return;
+  }
+  if (url.pathname === `${resourceBase}/full-mode/data`) {
+    sendJSON({
+      api_key_tracking_enabled: true,
+      api_key_uses_default_secret: false,
+      api_key_labels: {},
+    });
+    return;
+  }
+  if (url.pathname === `${resourceBase}/preferences`) {
+    sendJSON({});
+    return;
+  }
+  if (url.pathname === `${resourceBase}/stats/initial`) {
+    sendJSON({
+      generated_at: '2026-09-07T00:00:00.000Z',
+      last_used: '2026-09-07T00:00:00.000Z',
+      models: [],
+      sources: [],
+      api_keys: [
+        { ref: 'g1:0123456789abcdef0123456789abcdef', key: 'sk-test-key', status: 'available' },
+      ],
+      bucket_seconds: 86400,
+    });
+    return;
+  }
+  if (url.pathname === `${resourceBase}/stats/trends`) {
+    sendJSON({ model_series: [], bucket_seconds: 86400 });
+    return;
+  }
+  if (url.pathname === `${resourceBase}/stats/groups` || url.pathname === `${resourceBase}/requests`) {
+    sendJSON({ items: [], total: 0 });
+    return;
+  }
+  if (url.pathname === `${resourceBase}/costs`) {
+    sendJSON({ summary: { requests: 0, priced_requests: 0, unpriced_requests: 0 }, models: [], price_book_revision: 0 });
+    return;
+  }
+  if (url.pathname === `${resourceBase}/prices` || url.pathname === `${resourceBase}/full-mode/prices`) {
+    sendJSON({ prices: savedPrices, revision });
+    return;
+  }
+  sendJSON({});
+});
+
+await new Promise((resolve, reject) => {
+  server.once('error', reject);
+  server.listen(0, '127.0.0.1', resolve);
+});
+
+const address = server.address();
+const dashboardURL = `http://127.0.0.1:${address.port}${resourceBase}/dashboard#session=layout-test`;
+const browser = await chromium.launch({ executablePath: chromePath, headless: true });
+
+try {
+ const context=await browser.newContext({locale:'en-US',viewport:{width:1300,height:900}});
+ const page=await context.newPage();const errors=[];page.on('pageerror',e=>errors.push(String(e)));
+ await page.goto(dashboardURL);await page.locator('#pricingButton').click();
+ const panel=page.locator('.time-pricing');await panel.locator('summary').click();
+ await panel.locator('.time-zone').fill('Asia/Shanghai');await panel.locator('.add-time-tier').click();
+ const row=panel.locator('.time-tier-row');await row.locator('.time-name').fill('night');await row.locator('.time-days').fill('1,7');await row.locator('.time-input').fill('1');
+ async function saveAndReopen() {
+   await page.locator('#savePricing').click();
+   await page.locator('#pricingDialog').waitFor({state:'hidden'});
+   await page.locator('#pricingButton').click();
+   await panel.locator('summary').click();
+ }
+ async function checkFields() {
+   for (const [selector,value] of Object.entries({'.time-zone':'Asia/Shanghai','.time-name':'night','.time-days':'1,7','.time-input':'1','.time-start':'23:00','.time-end':'08:00'})) {
+     if(await panel.locator(selector).inputValue()!==value)throw Error('Lost field '+selector);
+   }
+ }
+ await saveAndReopen();await checkFields();
+ if(saves!==1||savedPrices.m.time_tiers[0].input!==1)throw Error('Save payload missing schedule');
+ // Repeat save to catch loss that could silently overwrite persisted settings.
+ await saveAndReopen();await checkFields();
+ await page.goto('about:blank');await page.goto(dashboardURL);await page.locator('#pricingButton').click();await panel.locator('summary').click();await checkFields();
+ await panel.locator('.add-time-tier').click();await panel.locator('.time-name').nth(1).fill('overlap');
+ await page.locator('#savePricing').click();
+ await page.waitForFunction(()=>document.getElementById('priceError').textContent.length>0);
+ if(saves!==2)throw Error('Overlap submitted');
+ await panel.locator('.time-tier-row').nth(1).locator('button').click();
+ await panel.locator('.time-tier-row').locator('button').click();
+ await saveAndReopen();
+ if(await panel.locator('.time-tier-row').count()!==0||savedPrices.m.time_tiers.length!==0)throw Error('Deletion not saved');
+ if(errors.length)throw Error(errors.join('\n'));
+ await page.screenshot({path:htmlPath+'.png',fullPage:true});
+ console.log('Time pricing browser round trip, overlap validation and deletion passed');
+} finally {await browser.close();await new Promise(resolve=>server.close(resolve));}