dsh-offpeak-guard 0.1.0 → 0.2.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.2.0 — 2026-11-05
+
+- 默认规则改为 DeepSeek 官方峰谷：工作日 09:00–12:00、14:00–18:00 峰时，周末与**中国法定节假日全天**谷价；内置 2026 年节假日列表。
+- 新增 `preset`：`auto` / `deepseek-official` / `workbuddy` / `custom`，按 provider 自动选择（WorkBuddy/CodeBuddy → workbuddy，其余 → 官方）。
+- 新增 `Config` schema：DSH 设置页可直接修改时区、窗口、豁免模型、提醒阈值等。
+- 新增 `DSH_OFFPEAK_*` 环境变量覆盖（优先级：环境变量 > 配置 > 默认），便于部署方统一注入。
+- 状态工具与界面显示当前规则和节假日状态。
+
 ## 0.1.0 — 2026-11-05
 
 - 首个公开版本。

package/README.en.md

@@ -1,8 +1,13 @@
 # Off-peak guard (dsh-offpeak-guard)
 
+[![npm](https://img.shields.io/npm/v/dsh-offpeak-guard?color=blue)](https://www.npmjs.com/package/dsh-offpeak-guard)
+
+Published on npm: install it from the DSH Plugins page, or run
+`dsh plugin --profile <profile> add dsh-offpeak-guard`.
+
 Schedule work around **DeepSeek peak/off-peak pricing** inside DeepSeek Harness:
 
-- **Time awareness**: weekdays `09:00–12:00` and `14:00–18:00` are peak price; every other hour (lunch, night, weekends) is off-peak at 50% (time zone `Asia/Shanghai` by default).
+- **Time awareness**: per DeepSeek's official pricing, Beijing-time weekdays (excluding Chinese statutory holidays) `09:00–12:00` and `14:00–18:00` are peak; every other hour (weekends, holidays, lunch, night) is off-peak at 50%. Built-in Chinese holidays cover 2026; add later years with `holidays`.
 - **Model awareness**: only sessions using a peak-priced model (model name contains `deepseek` by default; exempt models one by one with `exemptModels`) are paused/resumed. Other models are untouched.
 - **Work planning**:
   - peak starts → running tasks are paused (the pending inbox is kept, no message is lost);
@@ -31,15 +36,17 @@ Red blink within the alert window before peak (sample):
 
 ## Configuration
 
-The `config` of the `offpeak-guard` row in `cordis.patch.yml`:
+The `offpeak-guard` row's `config` in `cordis.patch.yml`, or the plugin settings form in DSH (a Config schema is declared):
 
 | Key | Default | Meaning |
 | --- | --- | --- |
 | `enabled` | `true` | Master switch |
-| `timezone` | `Asia/Shanghai` | Pricing time zone |
-| `peakWeekdays` | `[1,2,3,4,5]` | Weekdays that have peak windows (0 = Sunday) |
-| `peakWindows` | 09:00–12:00, 14:00–18:00 | Peak windows; edit these when DeepSeek changes prices |
-| `discount` | `0.5` | Off-peak discount, used for the "50%" label |
+| `preset` | `auto` | `auto` picks by provider: WorkBuddy/CodeBuddy → `workbuddy`, otherwise `deepseek-official`; can be pinned to `deepseek-official` / `workbuddy` / `custom` |
+| `timezone` | `Asia/Shanghai` | Pricing time zone (DeepSeek bills in Beijing time) |
+| `peakWeekdays` | `[1,2,3,4,5]` | Weekdays with peak windows (0 = Sunday); only used by `custom` |
+| `peakWindows` | 09:00–12:00, 14:00–18:00 | Peak windows; only used by `custom` |
+| `discount` | `0.5` | Off-peak discount, display only; only used by `custom` |
+| `holidays` | `[]` | Extra statutory holidays (`YYYY-MM-DD`), appended to the built-in 2026 list for the official/WorkBuddy presets |
 | `modelPattern` | `deepseek` | Model/provider name containing it counts as peak-priced |
 | `exemptModels` | `[]` | Model ids exempted one by one |
 | `pauseRunningOnPeak` | `true` | Pause running tasks when peak starts |
@@ -50,6 +57,36 @@ The `config` of the `offpeak-guard` row in `cordis.patch.yml`:
 | `bypassMinutes` | `10` | Grace period after a manual resume |
 | `alertMinutes` | `10` | Blink the sidebar clock within this many minutes of a switch (0 = never) |
 
+### Environment variables
+
+Deployments can inject settings with environment variables. Priority: **env > config > default**. Invalid values are ignored.
+
+| Variable | Example | Config field |
+| --- | --- | --- |
+| `DSH_OFFPEAK_ENABLED` | `0` / `1` | `enabled` |
+| `DSH_OFFPEAK_PRESET` | `custom` | `preset` |
+| `DSH_OFFPEAK_TIMEZONE` | `Asia/Shanghai` | `timezone` |
+| `DSH_OFFPEAK_PEAK_WEEKDAYS` | `1,2,3,4,5` | `peakWeekdays` |
+| `DSH_OFFPEAK_PEAK_WINDOWS` | `09:00-12:00,14:00-18:00` | `peakWindows` |
+| `DSH_OFFPEAK_DISCOUNT` | `0.5` | `discount` |
+| `DSH_OFFPEAK_HOLIDAYS` | `2026-10-01,2026-10-02` | `holidays` |
+| `DSH_OFFPEAK_MODEL_PATTERN` | `deepseek` | `modelPattern` |
+| `DSH_OFFPEAK_EXEMPT_MODELS` | `deepseek-v4-pro,deepseek-flash` | `exemptModels` |
+| `DSH_OFFPEAK_PAUSE_RUNNING` | `0` / `1` | `pauseRunningOnPeak` |
+| `DSH_OFFPEAK_DEFER_NEW` | `0` / `1` | `deferNewTurnsOnPeak` |
+| `DSH_OFFPEAK_RESUME` | `0` / `1` | `resumeOnOffPeak` |
+| `DSH_OFFPEAK_POLL_SECONDS` | `15` | `pollSeconds` |
+| `DSH_OFFPEAK_RESUME_DELAY_SECONDS` | `3` | `resumeDelaySeconds` |
+| `DSH_OFFPEAK_BYPASS_MINUTES` | `10` | `bypassMinutes` |
+| `DSH_OFFPEAK_ALERT_MINUTES` | `10` | `alertMinutes` |
+
+### Presets
+
+- `deepseek-official` (default): official weekday peak windows plus built-in 2026 Chinese holidays (holidays are off-peak all day).
+- `workbuddy`: same peak windows, labeled as WorkBuddy credit pricing; selected automatically for WorkBuddy/CodeBuddy providers.
+- `custom`: use `peakWeekdays` / `peakWindows` / `discount` / `holidays` exactly, for other providers or self-hosted pricing.
+
+
 ## Data
 
 State and snapshots live in `$DSH_HOME/offpeak-guard/`:
@@ -65,6 +102,8 @@ Pause uses `sessionController.cancel`, which ends only the current turn and keep
 
 ## Boundaries
 
+- Built-in statutory holidays cover 2026 only; after the 2027 schedule is published, upgrade the plugin or append dates with `holidays` / `DSH_OFFPEAK_HOLIDAYS`, otherwise holidays are treated as ordinary weekdays.
+- Named presets have fixed windows; use `preset: custom` for other providers or self-hosted pricing.
 - Only root sessions with a working directory are handled; subagent sessions are skipped so parents do not hang.
 - A plugin restart does not cancel tasks that are already running (so installing the plugin cannot kill the current conversation); the next peak or new task follows the rules again.
 - Manual `resume_now` grants those sessions a 10-minute grace period so they are not paused again immediately.

package/README.md

@@ -1,8 +1,13 @@
 # 错峰调度 · 峰谷守卫（dsh-offpeak-guard）
 
+[![npm](https://img.shields.io/npm/v/dsh-offpeak-guard?color=blue)](https://www.npmjs.com/package/dsh-offpeak-guard)
+
+已发布到 npm：在 DSH 的插件页搜索 `dsh-offpeak-guard` 安装，或运行
+`dsh plugin --profile <profile> add dsh-offpeak-guard`。
+
 在 DeepSeek Harness 里按 **DeepSeek 峰谷计价** 安排工作：
 
-- **时间识别**：工作日 `09:00–12:00`、`14:00–18:00` 为峰值原价；其余时间（含午间、夜间、周末）为谷价，按 5 折计费（默认 `Asia/Shanghai`）。
+- **时间识别**：按 DeepSeek 官方规则，北京时间周一至周五（不含中国法定节假日）`09:00–12:00`、`14:00–18:00` 为峰值原价；其余时间（含周末、法定节假日全天）为谷价，按 5 折计费。内置 2026 年法定节假日；后续年份可用 `holidays` 追加。
 - **模型识别**：只有使用峰谷计价模型（默认模型名含 `deepseek`，可在 `exemptModels` 里逐项豁免）的会话才会被暂停/恢复；用其它模型的会话不受影响。
 - **工作规划**：
   - 峰时开始 → 暂停正在运行的任务（保留待处理队列，不丢消息）；
@@ -31,15 +36,17 @@
 
 ## 配置
 
-`cordis.patch.yml` 里那一行 `offpeak-guard` 的 `config`：
+`cordis.patch.yml` 里那一行 `offpeak-guard` 的 `config`，或在 DSH 设置页的插件配置里修改（已声明 Config schema）：
 
 | 键 | 默认 | 说明 |
 | --- | --- | --- |
 | `enabled` | `true` | 总开关 |
-| `timezone` | `Asia/Shanghai` | 计价时区 |
-| `peakWeekdays` | `[1,2,3,4,5]` | 峰时适用的星期（0=周日） |
-| `peakWindows` | 09:00–12:00、14:00–18:00 | 峰时窗口；官方调价时改这里 |
-| `discount` | `0.5` | 谷价折扣，仅用于显示「5 折」 |
+| `preset` | `auto` | `auto` 按 provider 自动选：WorkBuddy/CodeBuddy → `workbuddy`，其余 → `deepseek-official`；也可固定为 `deepseek-official` / `workbuddy` / `custom` |
+| `timezone` | `Asia/Shanghai` | 计价时区（DeepSeek 计费按北京时间） |
+| `peakWeekdays` | `[1,2,3,4,5]` | 峰时适用的星期（0=周日）；仅 `custom` 预设使用 |
+| `peakWindows` | 09:00–12:00、14:00–18:00 | 峰时窗口；仅 `custom` 预设使用，官方调价时改这里 |
+| `discount` | `0.5` | 谷价折扣，仅用于显示「5 折」；仅 `custom` 预设使用 |
+| `holidays` | `[]` | 追加的法定节假日（`YYYY-MM-DD`），官方/WorkBuddy 预设会在内置 2026 列表上追加 |
 | `modelPattern` | `deepseek` | 模型名/供应商名包含它即视为峰谷计价模型 |
 | `exemptModels` | `[]` | 逐项豁免的模型 id |
 | `pauseRunningOnPeak` | `true` | 峰时开始时暂停正在运行的任务 |
@@ -50,6 +57,36 @@
 | `bypassMinutes` | `10` | 手动恢复后的豁免期，避免立刻又被暂停 |
 | `alertMinutes` | `10` | 左栏计时在距切换多少分钟内开始闪烁（0 = 不闪） |
 
+### 环境变量
+
+部署方可以用环境变量统一注入，优先级：**环境变量 > 配置 > 默认**。无效值会被忽略。
+
+| 环境变量 | 例子 | 对应配置 |
+| --- | --- | --- |
+| `DSH_OFFPEAK_ENABLED` | `0` / `1` | `enabled` |
+| `DSH_OFFPEAK_PRESET` | `custom` | `preset` |
+| `DSH_OFFPEAK_TIMEZONE` | `Asia/Shanghai` | `timezone` |
+| `DSH_OFFPEAK_PEAK_WEEKDAYS` | `1,2,3,4,5` | `peakWeekdays` |
+| `DSH_OFFPEAK_PEAK_WINDOWS` | `09:00-12:00,14:00-18:00` | `peakWindows` |
+| `DSH_OFFPEAK_DISCOUNT` | `0.5` | `discount` |
+| `DSH_OFFPEAK_HOLIDAYS` | `2026-10-01,2026-10-02` | `holidays` |
+| `DSH_OFFPEAK_MODEL_PATTERN` | `deepseek` | `modelPattern` |
+| `DSH_OFFPEAK_EXEMPT_MODELS` | `deepseek-v4-pro,deepseek-flash` | `exemptModels` |
+| `DSH_OFFPEAK_PAUSE_RUNNING` | `0` / `1` | `pauseRunningOnPeak` |
+| `DSH_OFFPEAK_DEFER_NEW` | `0` / `1` | `deferNewTurnsOnPeak` |
+| `DSH_OFFPEAK_RESUME` | `0` / `1` | `resumeOnOffPeak` |
+| `DSH_OFFPEAK_POLL_SECONDS` | `15` | `pollSeconds` |
+| `DSH_OFFPEAK_RESUME_DELAY_SECONDS` | `3` | `resumeDelaySeconds` |
+| `DSH_OFFPEAK_BYPASS_MINUTES` | `10` | `bypassMinutes` |
+| `DSH_OFFPEAK_ALERT_MINUTES` | `10` | `alertMinutes` |
+
+### 预设
+
+- `deepseek-official`（默认）：官方工作日峰时 + 内置 2026 法定节假日（节假日全天谷价）。
+- `workbuddy`：WorkBuddy 积分规则，峰时窗口与官方相同；按 provider 自动选择时用于标注来源。
+- `custom`：完全使用 `peakWeekdays` / `peakWindows` / `discount` / `holidays`，适合其他供应商或自建计价。
+
+
 ## 数据
 
 状态与快照都在 `$DSH_HOME/offpeak-guard/`：
@@ -65,6 +102,8 @@
 
 ## 边界
 
+- 内置法定节假日目前覆盖 2026 年；2027 年安排公布后可升级插件，或用 `holidays` / `DSH_OFFPEAK_HOLIDAYS` 追加，否则节假日会被当作普通工作日。
+- 命名预设的窗口是固定的；需要其他供应商/自建计价时用 `preset: custom` 配 `peakWindows`。
 - 只处理有工作目录、非子代理的根会话，避免打断子代理让父会话卡住。
 - 插件自身重启时不会主动打断正在跑的任务（避免刚安装就停掉当前对话）；之后进入峰时或新起任务仍按规则处理。
 - 手动「立即恢复」会给这些会话 10 分钟豁免，避免峰时刚恢复又被停回去。

package/cordis.patch.yml

@@ -1,12 +1,19 @@
 # dsh-offpeak-guard：DeepSeek 峰谷计价守卫。
-# 规则来自 DeepSeek 夜间折扣：工作日 09:00–12:00、14:00–18:00 为峰值原价，
-# 其余时间（含午间、夜间与周末）为谷价，按 5 折计费。
-# 官方调价时只改这里的 peakWindows / discount 即可。
+# 默认按 DeepSeek 官方「模型 & 价格」规则：
+#   北京时间周一至周五（不含中国法定节假日）09:00–12:00、14:00–18:00 为高峰；
+#   其余时段（含周末、法定节假日全天）为空闲，空闲价为高峰价的一半。
+# preset:
+#   auto              按 provider 自动选（WorkBuddy/CodeBuddy 走 workbuddy，其余走 deepseek-official）
+#   deepseek-official 官方规则（含内置 2026 法定节假日）
+#   workbuddy         WorkBuddy 积分规则（时段相同）
+#   custom            用下面 peakWeekdays / peakWindows / discount / holidays
+# 环境变量（部署方注入，优先级高于本文件）：DSH_OFFPEAK_*，详见 README。
 - insert:
     - id: offpeak-guard
       name: 'dsh-offpeak-guard'
       config:
         enabled: true
+        preset: 'auto'
         timezone: 'Asia/Shanghai'
         peakWeekdays: [1, 2, 3, 4, 5]
         peakWindows:
@@ -15,6 +22,7 @@
           - start: '14:00'
             end: '18:00'
         discount: 0.5
+        holidays: []
         modelPattern: 'deepseek'
         exemptModels: []
         pauseRunningOnPeak: true

package/index.js

@@ -2,19 +2,145 @@
  * dsh-offpeak-guard 入口（Host 半）。
  *
  * 三件事：
- *   1. 时间识别 —— 按 DeepSeek 夜间折扣规则判断现在处于峰值原价还是谷价；
+ *   1. 时间识别 —— 按 DeepSeek 官方峰谷规则（工作日 9–12、14–18，法定节假日全天谷价）判断时段；
  *   2. 模型识别 —— 只有使用峰谷计价模型的会话才会被暂停/恢复；
  *   3. 工作规划 —— 峰时暂停运行中的任务、延后新任务，谷价开始时自动恢复；
  *      另提供 offpeak_plan 把稍后要做的事排进谷价时段。
+ *
+ * 配置优先级：环境变量（DSH_OFFPEAK_*）> 设置/patch > 代码默认。
  */
+import z from '@deepseek-ai/schemastery';
 import { createGuard } from './lib/guard.js';
 import { createOffpeakTools } from './lib/tools.js';
 
 export const name = 'offpeak-guard';
 export const inject = ['tools'];
 
-export function apply(ctx, config = {}) {
-  const guard = createGuard(ctx, config ?? {});
+const OFFICIAL_WINDOWS = [
+  { start: '09:00', end: '12:00' },
+  { start: '14:00', end: '18:00' },
+];
+
+export const Config = z.object({
+  enabled: z.boolean().default(true),
+  preset: z.string().default('auto'),
+  timezone: z.string().default('Asia/Shanghai'),
+  peakWeekdays: z.array(z.natural().max(6)).default([1, 2, 3, 4, 5]),
+  peakWindows: z
+    .array(z.object({ start: z.string(), end: z.string() }))
+    .default(OFFICIAL_WINDOWS),
+  discount: z.number().min(0.1).max(1).default(0.5),
+  holidays: z.array(z.string()).default([]),
+  modelPattern: z.string().default('deepseek'),
+  exemptModels: z.array(z.string()).default([]),
+  pauseRunningOnPeak: z.boolean().default(true),
+  deferNewTurnsOnPeak: z.boolean().default(true),
+  resumeOnOffPeak: z.boolean().default(true),
+  pollSeconds: z.natural().min(5).max(300).default(15),
+  resumeDelaySeconds: z.natural().min(0).max(120).default(3),
+  bypassMinutes: z.natural().min(0).max(120).default(10),
+  alertMinutes: z.natural().min(0).max(120).default(10),
+});
+
+function parseBoolean(value) {
+  const text = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'on'].includes(text)) return true;
+  if (['0', 'false', 'no', 'off'].includes(text)) return false;
+  return undefined;
+}
+
+function parseNumber(value) {
+  const number = Number(String(value).trim());
+  return Number.isFinite(number) ? number : undefined;
+}
+
+function parseWeekdays(value) {
+  const days = String(value)
+    .split(',')
+    .map((item) => Number(item.trim()))
+    .filter((item) => Number.isInteger(item) && item >= 0 && item <= 6);
+  return days.length > 0 ? days : undefined;
+}
+
+function parseWindows(value) {
+  const windows = [];
+  for (const part of String(value).split(',')) {
+    const match = /^\s*(\d{1,2}:\d{2})\s*-\s*(\d{1,2}:\d{2})\s*$/.exec(part);
+    if (match !== null) windows.push({ start: match[1], end: match[2] });
+  }
+  return windows.length > 0 ? windows : undefined;
+}
+
+function parseList(value) {
+  const items = String(value)
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return items.length > 0 ? items : undefined;
+}
+
+/**
+ * 读取部署环境变量。用于容器/CI/多实例统一注入，避免每个用户改 patch。
+ * 无效值忽略，不改变原有配置。
+ */
+export function envConfig(env = process.env) {
+  const out = {};
+  if (env.DSH_OFFPEAK_ENABLED !== undefined) {
+    const value = parseBoolean(env.DSH_OFFPEAK_ENABLED);
+    if (value !== undefined) out.enabled = value;
+  }
+  if (env.DSH_OFFPEAK_PRESET) out.preset = String(env.DSH_OFFPEAK_PRESET).trim();
+  if (env.DSH_OFFPEAK_TIMEZONE) out.timezone = String(env.DSH_OFFPEAK_TIMEZONE).trim();
+  if (env.DSH_OFFPEAK_PEAK_WEEKDAYS !== undefined) {
+    const value = parseWeekdays(env.DSH_OFFPEAK_PEAK_WEEKDAYS);
+    if (value !== undefined) out.peakWeekdays = value;
+  }
+  if (env.DSH_OFFPEAK_PEAK_WINDOWS !== undefined) {
+    const value = parseWindows(env.DSH_OFFPEAK_PEAK_WINDOWS);
+    if (value !== undefined) out.peakWindows = value;
+  }
+  if (env.DSH_OFFPEAK_DISCOUNT !== undefined) {
+    const value = parseNumber(env.DSH_OFFPEAK_DISCOUNT);
+    if (value !== undefined) out.discount = value;
+  }
+  if (env.DSH_OFFPEAK_HOLIDAYS !== undefined) {
+    const value = parseList(env.DSH_OFFPEAK_HOLIDAYS);
+    if (value !== undefined) out.holidays = value;
+  }
+  if (env.DSH_OFFPEAK_MODEL_PATTERN) out.modelPattern = String(env.DSH_OFFPEAK_MODEL_PATTERN).trim();
+  if (env.DSH_OFFPEAK_EXEMPT_MODELS !== undefined) {
+    const value = parseList(env.DSH_OFFPEAK_EXEMPT_MODELS);
+    if (value !== undefined) out.exemptModels = value;
+  }
+  const booleans = [
+    ['DSH_OFFPEAK_PAUSE_RUNNING', 'pauseRunningOnPeak'],
+    ['DSH_OFFPEAK_DEFER_NEW', 'deferNewTurnsOnPeak'],
+    ['DSH_OFFPEAK_RESUME', 'resumeOnOffPeak'],
+  ];
+  for (const [key, field] of booleans) {
+    if (env[key] !== undefined) {
+      const value = parseBoolean(env[key]);
+      if (value !== undefined) out[field] = value;
+    }
+  }
+  const numbers = [
+    ['DSH_OFFPEAK_POLL_SECONDS', 'pollSeconds'],
+    ['DSH_OFFPEAK_RESUME_DELAY_SECONDS', 'resumeDelaySeconds'],
+    ['DSH_OFFPEAK_BYPASS_MINUTES', 'bypassMinutes'],
+    ['DSH_OFFPEAK_ALERT_MINUTES', 'alertMinutes'],
+  ];
+  for (const [key, field] of numbers) {
+    if (env[key] !== undefined) {
+      const value = parseNumber(env[key]);
+      if (value !== undefined) out[field] = value;
+    }
+  }
+  return out;
+}
+
+export function apply(ctx, rawConfig = {}) {
+  const config = { ...(rawConfig ?? {}), ...envConfig() };
+  const guard = createGuard(ctx, config);
 
   ctx.effect(() => guard.start(), 'offpeak-guard: tick loop');
 

package/lib/guard.js

@@ -74,6 +74,7 @@ export function createGuard(ctx, config = {}) {
 
   const bypass = new Map();
   const deferring = new Set();
+  const rulesCache = new Map();
   const busy = { tick: false, pause: false, resume: false, plans: false };
   let timer = null;
   let lastPhase = null;
@@ -161,6 +162,22 @@ export function createGuard(ctx, config = {}) {
     return session;
   }
 
+  function rulesFor(provider) {
+    const key = String(provider ?? '');
+    if (!rulesCache.has(key)) rulesCache.set(key, resolveRules(config, provider));
+    return rulesCache.get(key);
+  }
+
+  function currentProvider() {
+    const active = liveAgents().find((agent) => agent.status === 'running');
+    if (active !== undefined) return modelOf(active).provider;
+    try {
+      return service('agentDefaultModel')?.currentSelection?.()?.provider ?? null;
+    } catch {
+      return null;
+    }
+  }
+
   const modelLabelCache = new Map();
 
   async function resolveModelLabel(provider, model) {
@@ -205,15 +222,19 @@ export function createGuard(ctx, config = {}) {
         peakPriced: isPeakPriced(route.provider, route.model),
       };
     }
+    const activeRules = rulesFor(currentProvider());
     return {
       version: 1,
       generatedAt: Date.now(),
-      timezone: rules.timezone,
-      peakWeekdays: rules.peakWeekdays,
-      peakWindows: rules.peakWindows.map((item) => ({ start: item.start, end: item.end })),
-      discount: rules.discount,
+      preset: desc.preset,
+      presetLabel: desc.presetLabel,
+      timezone: desc.timezone,
+      peakWeekdays: activeRules.peakWeekdays,
+      peakWindows: activeRules.peakWindows.map((item) => ({ start: item.start, end: item.end })),
+      discount: desc.discount,
       phase: desc.phase,
       phaseLabel: desc.phaseLabel,
+      holiday: desc.holiday === true,
       localTime: desc.localTime,
       weekday: desc.weekday,
       window: desc.window,
@@ -261,7 +282,8 @@ export function createGuard(ctx, config = {}) {
   }
 
   function resumeText(item) {
-    const when = formatDateClock(new Date(Number(item.at) || Date.now()), rules.timezone);
+    const itemRules = rulesFor(item.provider);
+    const when = formatDateClock(new Date(Number(item.at) || Date.now()), itemRules.timezone);
     const modelText = item.model ? `（模型 ${item.model}）` : '';
     return [
       `【错峰调度】谷价时段已经开始，现在继续执行任务。`,
@@ -314,8 +336,6 @@ export function createGuard(ctx, config = {}) {
     try {
       const state = await stateFile.read();
       const now = Date.now();
-      const desc = describeWindow(now, rules);
-      if (desc.phase !== 'peak') return [];
       const paused = [];
       let changed = false;
       for (const agent of liveAgents()) {
@@ -325,6 +345,8 @@ export function createGuard(ctx, config = {}) {
         const { provider, model } = modelOf(agent);
         if (!isPeakPriced(provider, model)) continue;
         if ((bypass.get(agent.id) ?? 0) > now) continue;
+        const desc = describeWindow(now, rulesFor(provider));
+        if (desc.phase !== 'peak') continue;
         const existing = state.interrupted.find((item) => item.sessionId === agent.id && item.status === 'paused');
         if (existing !== undefined) {
           existing.at = now;
@@ -438,13 +460,13 @@ export function createGuard(ctx, config = {}) {
     if (disposed || !options.enabled || !options.deferNewTurnsOnPeak || busy.pause) return;
     if (deferring.has(agent.id)) return;
     const now = Date.now();
-    const desc = describeWindow(now, rules);
-    if (desc.phase !== 'peak') return;
     if ((bypass.get(agent.id) ?? 0) > now) return;
     const session = guardableSession(agent);
     if (session === null) return;
     const { provider, model } = modelOf(agent);
     if (!isPeakPriced(provider, model)) return;
+    const desc = describeWindow(now, rulesFor(provider));
+    if (desc.phase !== 'peak') return;
     deferring.add(agent.id);
     try {
       const state = await stateFile.read();
@@ -471,7 +493,7 @@ export function createGuard(ctx, config = {}) {
         await stateFile.write(state);
         log('warn', `暂停新任务 ${agent.id} 失败：${messageOf(error)}`);
       }
-      await publish(describeWindow(Date.now(), rules), state);
+      await publish(describeWindow(Date.now(), rulesFor(provider)), state);
     } finally {
       deferring.delete(agent.id);
     }
@@ -483,7 +505,7 @@ export function createGuard(ctx, config = {}) {
     try {
       const state = await stateFile.read();
       const now = Date.now();
-      const desc = describeWindow(now, rules);
+      const desc = describeWindow(now, rulesFor(currentProvider()));
 
       if (!restoreChecked) {
         restoreChecked = true;
@@ -552,7 +574,7 @@ export function createGuard(ctx, config = {}) {
 
   async function status() {
     const state = await stateFile.read();
-    const desc = describeWindow(Date.now(), rules);
+    const desc = describeWindow(Date.now(), rulesFor(currentProvider()));
     await publish(desc, state);
     return { desc, state, snapshot: await snapshotOf(desc, state) };
   }

package/lib/holidays.js

@@ -0,0 +1,60 @@
+/**
+ * 中国法定节假日（用于 DeepSeek 官方峰谷规则）。
+ *
+ * 官方口径（api-docs.deepseek.com/zh-cn/quick_start/pricing）：
+ *   北京时间周一至周五（不含中国法定节假日）09:00–12:00、14:00–18:00 为高峰；
+ *   其余时段，包括周末及法定节假日全天，均为空闲（谷价）。
+ *
+ * 调休上班的周末也按空闲处理，所以这里只需要“放假日”列表，不需要补班列表。
+ * 官方每年 11 月左右公布下一年安排；列表过期时用户可以用配置项 holidays 追加/覆盖。
+ */
+export const CN_HOLIDAYS = {
+  2026: [
+    '2026-01-01',
+    '2026-01-02',
+    '2026-01-03',
+    // 春节
+    '2026-02-15',
+    '2026-02-16',
+    '2026-02-17',
+    '2026-02-18',
+    '2026-02-19',
+    '2026-02-20',
+    '2026-02-21',
+    '2026-02-22',
+    '2026-02-23',
+    // 清明
+    '2026-04-04',
+    '2026-04-05',
+    '2026-04-06',
+    // 劳动节
+    '2026-05-01',
+    '2026-05-02',
+    '2026-05-03',
+    '2026-05-04',
+    '2026-05-05',
+    // 端午
+    '2026-06-19',
+    '2026-06-20',
+    '2026-06-21',
+    // 中秋
+    '2026-09-25',
+    '2026-09-26',
+    '2026-09-27',
+    // 国庆
+    '2026-10-01',
+    '2026-10-02',
+    '2026-10-03',
+    '2026-10-04',
+    '2026-10-05',
+    '2026-10-06',
+    '2026-10-07',
+  ],
+  // 2027 年安排发布后可在这里补；也可以用 config.holidays 临时追加。
+  2027: [],
+};
+
+/** 所有内置节假日日期（YYYY-MM-DD）的并集。 */
+export function builtinHolidays() {
+  return Object.values(CN_HOLIDAYS).flat();
+}

package/lib/peak.js

@@ -1,26 +1,71 @@
 /**
  * 峰谷时间引擎（纯函数，无框架依赖）。
  *
- * 规则来自 DeepSeek 的「夜间折扣」：工作日 09:00–12:00、14:00–18:00 为高峰原价，
- * 其余时间（含午间、夜间与周末）为谷价，谷价按 5 折计费。时区默认 Asia/Shanghai。
- * 所有窗口都由配置给出，不写死在调用处，方便官方调价后只改 patch。
+ * 规则来自 DeepSeek 官方「模型 & 价格」：
+ *   北京时间周一至周五（不含中国法定节假日）09:00–12:00、14:00–18:00 为高峰；
+ *   其余时段（含周末、法定节假日全天）为空闲，空闲价为高峰价的一半。
+ * 另保留 WorkBuddy 积分预设（时段相同，仅用于按 provider 标注来源）与自定义预设。
  */
+import { builtinHolidays } from './holidays.js';
 
 const MINUTE_MS = 60_000;
 const DAY_MS = 86_400_000;
 const WEEKDAY_INDEX = { Sun: 0, Mon: 1, Tue: 2, Wed: 3, Thu: 4, Fri: 5, Sat: 6 };
 const WEEKDAY_NAMES = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
 
+export const OFFICIAL_WINDOWS = [
+  { start: '09:00', end: '12:00' },
+  { start: '14:00', end: '18:00' },
+];
+
+export const PRESETS = {
+  'deepseek-official': {
+    label: 'DeepSeek 官方',
+    timezone: 'Asia/Shanghai',
+    peakWeekdays: [1, 2, 3, 4, 5],
+    peakWindows: OFFICIAL_WINDOWS,
+    discount: 0.5,
+    holidays: 'official',
+  },
+  workbuddy: {
+    label: 'WorkBuddy 积分',
+    timezone: 'Asia/Shanghai',
+    peakWeekdays: [1, 2, 3, 4, 5],
+    peakWindows: OFFICIAL_WINDOWS,
+    discount: 0.5,
+    holidays: 'official',
+  },
+  custom: {
+    label: '自定义',
+    timezone: 'Asia/Shanghai',
+    peakWeekdays: [1, 2, 3, 4, 5],
+    peakWindows: OFFICIAL_WINDOWS,
+    discount: 0.5,
+    holidays: 'config',
+  },
+};
+
 export const DEFAULT_RULES = {
+  preset: 'deepseek-official',
+  presetLabel: 'DeepSeek 官方',
   timezone: 'Asia/Shanghai',
   peakWeekdays: [1, 2, 3, 4, 5],
-  peakWindows: [
-    { start: '09:00', end: '12:00' },
-    { start: '14:00', end: '18:00' },
-  ],
+  peakWindows: OFFICIAL_WINDOWS,
   discount: 0.5,
+  holidays: new Set(),
 };
 
+/** 按 provider 自动选预设：WorkBuddy/CodeBuddy 走积分预设，其余走官方。 */
+export function resolvePreset(config = {}, provider) {
+  const explicit = typeof config.preset === 'string' ? config.preset.trim() : 'auto';
+  if (explicit !== 'auto' && explicit !== '') {
+    return PRESETS[explicit] === undefined ? 'deepseek-official' : explicit;
+  }
+  const name = String(provider ?? '').toLowerCase();
+  if (/workbuddy|codebuddy/.test(name)) return 'workbuddy';
+  return 'deepseek-official';
+}
+
 /** 解析 "HH:MM"。非法值返回 null，由调用方决定退回默认。 */
 function parseHm(value) {
   if (typeof value !== 'string') return null;
@@ -40,28 +85,10 @@ function hmText(minutes) {
   return `${pad2(Math.floor(minutes / 60))}:${pad2(minutes % 60)}`;
 }
 
-/**
- * 把 patch 里的原始配置归一成引擎可用的规则；坏值逐项退回默认，不整体失败。
- * @param {Record<string, unknown>} [config]
- */
-export function resolveRules(config = {}) {
-  const timezone =
-    typeof config.timezone === 'string' && config.timezone.trim() !== ''
-      ? config.timezone.trim()
-      : DEFAULT_RULES.timezone;
-
-  let weekdays = Array.isArray(config.peakWeekdays)
-    ? config.peakWeekdays.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0 && value <= 6)
-    : DEFAULT_RULES.peakWeekdays;
-  if (weekdays.length === 0) weekdays = [...DEFAULT_RULES.peakWeekdays];
-  weekdays = [...new Set(weekdays)].sort((a, b) => a - b);
-
-  const rawWindows =
-    Array.isArray(config.peakWindows) && config.peakWindows.length > 0
-      ? config.peakWindows
-      : DEFAULT_RULES.peakWindows;
+function parseWindows(rawWindows, fallback) {
+  const source = Array.isArray(rawWindows) && rawWindows.length > 0 ? rawWindows : fallback;
   const windows = [];
-  for (const raw of rawWindows) {
+  for (const raw of source) {
     const start = parseHm(raw?.start);
     const end = parseHm(raw?.end);
     if (start === null || end === null) continue;
@@ -71,7 +98,7 @@ export function resolveRules(config = {}) {
     windows.push({ startMin, endMin, start: hmText(startMin), end: hmText(endMin) });
   }
   if (windows.length === 0) {
-    for (const raw of DEFAULT_RULES.peakWindows) {
+    for (const raw of fallback) {
       const start = parseHm(raw.start);
       const end = parseHm(raw.end);
       windows.push({
@@ -83,11 +110,58 @@ export function resolveRules(config = {}) {
     }
   }
   windows.sort((a, b) => a.startMin - b.startMin);
+  return windows;
+}
+
+function normalizeDates(values) {
+  if (!Array.isArray(values)) return [];
+  return values
+    .map((value) => String(value).trim())
+    .filter((value) => /^\d{4}-\d{2}-\d{2}$/.test(value));
+}
+
+/**
+ * 把 patch / 设置 / 环境变量归一成引擎规则。
+ * 命名预设使用预设自带的时间窗口；custom 预设使用配置里的窗口。
+ * @param {Record<string, unknown>} [config]
+ * @param {string} [provider] 当前会话的 provider，用于 auto 预设判断
+ */
+export function resolveRules(config = {}, provider) {
+  const presetName = resolvePreset(config, provider);
+  const preset = PRESETS[presetName] ?? PRESETS['deepseek-official'];
+  const custom = presetName === 'custom';
+
+  const timezone =
+    typeof config.timezone === 'string' && config.timezone.trim() !== ''
+      ? config.timezone.trim()
+      : preset.timezone;
+
+  let weekdays = custom && Array.isArray(config.peakWeekdays)
+    ? config.peakWeekdays.map((value) => Number(value)).filter((value) => Number.isInteger(value) && value >= 0 && value <= 6)
+    : preset.peakWeekdays;
+  if (weekdays.length === 0) weekdays = [...preset.peakWeekdays];
+  weekdays = [...new Set(weekdays)].sort((a, b) => a - b);
+
+  const windows = parseWindows(custom ? config.peakWindows : undefined, preset.peakWindows);
+
+  const rawDiscount = custom ? Number(config.discount) : preset.discount;
+  const discount = Number.isFinite(rawDiscount) && rawDiscount > 0 && rawDiscount <= 1 ? rawDiscount : 0.5;
 
-  const rawDiscount = Number(config.discount);
-  const discount = Number.isFinite(rawDiscount) && rawDiscount > 0 && rawDiscount <= 1 ? rawDiscount : DEFAULT_RULES.discount;
+  const configuredHolidays = normalizeDates(config.holidays);
+  const holidayDates = preset.holidays === 'official'
+    ? [...builtinHolidays(), ...configuredHolidays]
+    : configuredHolidays;
+  const holidays = new Set(holidayDates);
 
-  return { timezone, peakWeekdays: weekdays, peakWindows: windows, discount };
+  return {
+    preset: presetName,
+    presetLabel: preset.label,
+    timezone,
+    peakWeekdays: weekdays,
+    peakWindows: windows,
+    discount,
+    holidays,
+  };
 }
 
 const formatterCache = new Map();
@@ -126,6 +200,14 @@ export function zonedParts(date, timeZone) {
   };
 }
 
+function dateKey(parts) {
+  return `${parts.year}-${pad2(parts.month)}-${pad2(parts.day)}`;
+}
+
+function isHoliday(parts, rules) {
+  return rules.holidays instanceof Set && rules.holidays.has(dateKey(parts));
+}
+
 function zoneOffsetMs(date, timeZone) {
   const parts = zonedParts(date, timeZone);
   const asUtc = Date.UTC(parts.year, parts.month - 1, parts.day, parts.hour, parts.minute, parts.second);
@@ -156,17 +238,28 @@ function dayAt(parts, offsetDays) {
   };
 }
 
+function dayParts(day) {
+  return {
+    year: day.year,
+    month: day.month,
+    day: day.day,
+    weekday: day.weekday,
+  };
+}
+
 /** 当前时刻所处的计价时段。 */
 export function phaseAt(date, rules) {
   const parts = zonedParts(date, rules.timezone);
   const minute = parts.hour * 60 + parts.minute;
-  const peakDay = rules.peakWeekdays.includes(parts.weekday);
+  const holiday = isHoliday(parts, rules);
+  const peakDay = !holiday && rules.peakWeekdays.includes(parts.weekday);
   const window = peakDay ? rules.peakWindows.find((item) => minute >= item.startMin && minute < item.endMin) : undefined;
   return {
     phase: window === undefined ? 'offpeak' : 'peak',
     window: window ?? null,
     parts,
     minute,
+    holiday,
   };
 }
 
@@ -186,9 +279,10 @@ export function nextBoundary(date, rules) {
     };
   }
   const nowMinutes = current.minute + parts.second / 60;
-  for (let offset = 0; offset <= 8; offset += 1) {
+  for (let offset = 0; offset <= 10; offset += 1) {
     const day = dayAt(parts, offset);
     if (!rules.peakWeekdays.includes(day.weekday)) continue;
+    if (isHoliday(dayParts(day), rules)) continue;
     for (const window of rules.peakWindows) {
       if (offset === 0 && window.startMin <= nowMinutes) continue;
       return {
@@ -259,10 +353,13 @@ export function describeWindow(nowMs, rules) {
   const discountText = `${(rules.discount * 10).toFixed(1).replace(/\.0$/, '')} 折`;
   return {
     now: nowMs,
+    preset: rules.preset,
+    presetLabel: rules.presetLabel,
     timezone: rules.timezone,
     phase: current.phase,
     phaseLabel: current.phase === 'peak' ? '峰值原价' : `谷价 ${discountText}`,
     discount: rules.discount,
+    holiday: current.holiday,
     localTime: formatDateClock(now, rules.timezone),
     weekday: formatWeekday(now, rules.timezone),
     window: current.phase === 'peak' ? { start: bounds.start, end: bounds.end, startAt: bounds.startAt, endAt: bounds.endAt } : null,

package/lib/tools.js

@@ -24,7 +24,24 @@ function timeLine(desc) {
 }
 
 function phaseLine(desc) {
-  return `时段：${desc.phaseLabel}`;
+  return `时段：${desc.phaseLabel}${desc.holiday === true ? '（法定节假日，全天谷价）' : ''}`;
+}
+
+function weekdayText(days) {
+  const names = ['周日', '周一', '周二', '周三', '周四', '周五', '周六'];
+  const list = Array.isArray(days) ? [...new Set(days)].sort((a, b) => a - b) : [];
+  if (list.length === 7) return '每天';
+  if (list.length === 5 && list.every((day, index) => day === index + 1)) return '周一至周五';
+  if (list.length === 0) return '无';
+  return list.map((day) => names[day] ?? String(day)).join('、');
+}
+
+function ruleLine(desc, snapshot) {
+  const windows = Array.isArray(snapshot.peakWindows)
+    ? snapshot.peakWindows.map((item) => `${item.start}–${item.end}`).join('、')
+    : '—';
+  const holiday = desc.holiday === true ? ' · 今天法定节假日全天空闲' : '';
+  return `规则：${desc.presetLabel} · ${weekdayText(snapshot.peakWeekdays)} ${windows}${holiday}`;
 }
 
 function nextLine(desc) {
@@ -85,6 +102,7 @@ function statusText(desc, snapshot) {
   return [
     timeLine(desc),
     phaseLine(desc),
+    ruleLine(desc, snapshot),
     nextLine(desc),
     modelLine(snapshot),
     guardLine(snapshot),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-offpeak-guard",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "DeepSeek peak/off-peak pricing guard for DSH: detects the price window and current model, pauses running tasks at peak, resumes them automatically when off-peak begins, and schedules work for the next off-peak window.",
   "private": false,
   "type": "module",
@@ -56,6 +56,9 @@
     "node": ">=22.5",
     "dsh": ">=0.2.1-rc.2 <0.3.0"
   },
+  "dependencies": {
+    "@deepseek-ai/schemastery": "^3.18.5"
+  },
   "dsh": {
     "bundle": {
       "patch": "./cordis.patch.yml"