@genee/omp-opsx-addon 0.1.0

package/lib/model-selector.ts

@@ -0,0 +1,307 @@
+/**
+ * Model selector — picks the best `Model<Api>` for a given role.
+ *
+ * Sorts by (in order):
+ *   1. Effective gap = tierGap + surgePenalty (closest to expected wins).
+ *      Surge penalty is applied during peak pricing windows and when
+ *      monthly-plan providers have available quota (to avoid PAYG spend).
+ *   2. Rank (higher tier wins).
+ *   3. Plan priority: monthly-plan providers (0) before PAYG (1).
+ *   4. Remaining fraction (healthier first).
+ *   5. Cost (cheaper first).
+ *   6. Reputation (higher first).
+ *   7. Name (stable tie-break).
+ */
+
+import type { Model, Api } from '@oh-my-pi/pi-catalog/types';
+import {
+    type TierName,
+    type TierOverride,
+    DEFAULT_ROLE_TIER,
+    scoreModelWithProvider,
+    tierNameToRank,
+} from './model-tiers.js';
+import type { ProviderHealth } from './usage-resolver.js';
+import { getPeakStatus, isGLM5Model, type PeakStatus } from './peak-detector.js';
+
+export interface ScoredCandidate {
+    model: Model<Api>;
+    selector: string;
+    rank: number;
+    tier: TierName;
+    reason: string;
+    exhausted: boolean;
+    remainingFraction?: number;
+    tierGap: number;
+    costInput: number;
+    /** 0 = provider has a monthly plan, 1 = PAYG / unknown. Lower preferred. */
+    planPriority: number;
+    /** Coding reputation 0-100 from model family (SWE-bench ranking). Higher preferred. */
+    reputation: number;
+    /** Surge pricing penalty (0 = normal, 1+ = penalized). Added to tierGap for sorting. */
+    surgePenalty: number;
+}
+export interface SelectorResult {
+    role: string;
+    expectedTier: TierName;
+    picked: Model<Api> | null;
+    candidates: ScoredCandidate[];
+    allCandidates: ScoredCandidate[];
+    decision: string;
+    pickedReason: string | null;
+}
+
+export interface SelectorInput {
+    role: string;
+    models: Model<Api>[];
+    roleTiers?: Record<string, TierName>;
+    tierOverrides?: TierOverride[];
+    health?: Map<string, ProviderHealth>;
+    allowlist?: string[];
+    /** Provider names that have a monthly plan subscription. */
+    planProviders?: Set<string>;
+    /** Pre-computed peak status (for testing). If omitted, computed from current time. */
+    peakStatus?: PeakStatus;
+}
+
+function globToRegex(pattern: string): RegExp {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`, 'i');
+}
+
+export type CursorBucket = 'builtin' | 'other';
+
+const BUILTIN_ID_RE = /\b(auto|composer|grok|cursor-small|cursor-fast)\b/i;
+
+export function classifyCursorBucket(
+    model: { id: string; name?: string },
+    autoBucketModels?: string[],
+): CursorBucket {
+    const idLower = model.id.toLowerCase();
+    if (autoBucketModels?.some((m) => m.toLowerCase() === idLower)) return 'builtin';
+    const hay = `${model.name ?? ''} ${model.id}`;
+    if (BUILTIN_ID_RE.test(hay)) return 'builtin';
+    return 'other';
+}
+
+export function candidateQuota(
+    model: { id: string; name?: string; provider: string },
+    health: ProviderHealth | undefined,
+): { exhausted: boolean; remainingFraction?: number } {
+    if (!health) return { exhausted: false, remainingFraction: undefined };
+    if (health.policy !== 'bucket') {
+        return { exhausted: health.exhausted, remainingFraction: health.worstRemainingFraction };
+    }
+    const bucket = classifyCursorBucket(model, health.autoBucketModels);
+    const win = health.windows.find((w) => w.id === bucket) ?? health.windows.find((w) => w.id === 'other');
+    const ondemand = health.windows.find((w) => w.id === 'ondemand');
+    if (!win) {
+        return { exhausted: health.exhausted, remainingFraction: health.worstRemainingFraction };
+    }
+    if (win.exhausted) {
+        if (ondemand && !ondemand.exhausted) {
+            return { exhausted: false, remainingFraction: ondemand.remaining };
+        }
+        return { exhausted: true, remainingFraction: win.remaining ?? 0 };
+    }
+    return { exhausted: false, remainingFraction: win.remaining };
+}
+
+export const DEFAULT_PLAN_PROVIDERS = new Set([
+    'minimax-code-cn',
+    'opencode-go',
+    'zhipu-coding-plan',
+    'kimi',
+    'openai-codex',
+    'cursor',
+]);
+
+export function mergePlanProviders(extra?: readonly string[]): Set<string> {
+    return new Set([...DEFAULT_PLAN_PROVIDERS, ...(extra ?? [])]);
+}
+
+function isAllowlisted(selector: string, allowlist: string[] | undefined): boolean {
+    if (!allowlist || allowlist.length === 0) return true;
+    return allowlist.some((p) => globToRegex(p).test(selector));
+}
+
+/**
+ * Extract a numeric generation from a model id, so we can prefer
+ * newer models (v4 > v3, M3 > M2) within the same provider+tier.
+ * Returns [major, minor]; [0,0] when no version pattern is found.
+ */
+function extractGeneration(modelId: string): [number, number] {
+    // v4, v4-pro, deepseek-v4-flash → major=4
+    const vMatch = modelId.match(/\bv(\d+)\b/i);
+    if (vMatch) return [parseInt(vMatch[1], 10), 0];
+    // MiniMax M3, M2.7 → major=3 minor=0, or parse "2.7" from "M2.7"
+    const mmMatch = modelId.match(/\bM(\d+)(?:[._-](\d+))?\b/i);
+    if (mmMatch) return [parseInt(mmMatch[1], 10), parseInt(mmMatch[2] ?? '0', 10)];
+    // kimi-k2.7, glm-5.2 → major=2 minor=7
+    const kMatch = modelId.match(/\b[kqg](\d+)(?:[._-](\d+))?\b/i);
+    if (kMatch) return [parseInt(kMatch[1], 10), parseInt(kMatch[2] ?? '0', 10)];
+    // claude-opus-4-8, claude-sonnet-4-5 → hyphen-separated version
+    // claude-opus-4-8 → [4,8]; claude-opus-4-20250514 → [4,0] (date-stamp stripped)
+    const hMatch = modelId.match(/\b(claude|opus|sonnet|haiku|mythos|fable)[._-]?(\d+)[._-](\d+)\b/i);
+    if (hMatch) {
+        const minor = parseInt(hMatch[3], 10);
+        return [parseInt(hMatch[2], 10), minor >= 10_000 ? 0 : minor];
+    }
+    // claude-fable-5 → [5,0]
+    const hSingle = modelId.match(/\b(claude|opus|sonnet|haiku|mythos|fable)[._-]?(\d+)\b/i);
+    if (hSingle) return [parseInt(hSingle[2], 10), 0];
+    // gpt-5.5, glm-4.7 → decimal version
+    const dMatch = modelId.match(/\b(\d+)\.(\d+)\b/);
+    if (dMatch) return [parseInt(dMatch[1], 10), parseInt(dMatch[2], 10)];
+    return [0, 0];
+}
+
+/** Compare two generation tuples: higher major, then minor. */
+function isNewer(a: [number, number], b: [number, number]): boolean {
+    if (a[0] !== b[0]) return a[0] > b[0];
+    return a[1] > b[1];
+}
+
+/** Keep the best candidate per (provider, tier) group.
+ *  Prefers latest generation first, then reputation as tiebreaker. */
+function dedupByProviderTier(candidates: ScoredCandidate[]): ScoredCandidate[] {
+    const best = new Map<string, ScoredCandidate>();
+    for (const c of candidates) {
+        const key = `${c.model.provider}:${c.tier}`;
+        const existing = best.get(key);
+        if (!existing) {
+            best.set(key, c);
+            continue;
+        }
+        const cGen = extractGeneration(c.model.id);
+        const eGen = extractGeneration(existing.model.id);
+        if (isNewer(cGen, eGen)) {
+            best.set(key, c);
+        } else if (cGen[0] === eGen[0] && cGen[1] === eGen[1]) {
+            // Same generation → reputation tiebreaks
+            if (c.reputation > existing.reputation ||
+                (c.reputation === existing.reputation && c.rank > existing.rank)) {
+                best.set(key, c);
+            }
+        }
+    }
+    return [...best.values()];
+}
+
+export function selectModel(input: SelectorInput): SelectorResult {
+    const { role, models, tierOverrides, health, allowlist, planProviders, peakStatus } = input;
+    const roleTiers = input.roleTiers ?? DEFAULT_ROLE_TIER;
+    const expectedTier: TierName = roleTiers[role] ?? DEFAULT_ROLE_TIER[role] ?? 'mid';
+    const expectedRank = tierNameToRank(expectedTier);
+
+    const allCandidates: ScoredCandidate[] = models.map((model) => {
+        const selector = `${model.provider}/${model.id}`;
+        const score = scoreModelWithProvider(model.provider, model.id, model.name, tierOverrides);
+        const h = health?.get(model.provider);
+        const quota = candidateQuota(model, h);
+        return {
+            model,
+            selector,
+            rank: score.rank,
+            tier: score.tier,
+            reason: score.reason,
+            exhausted: quota.exhausted,
+            remainingFraction: quota.remainingFraction,
+            tierGap: Math.abs(score.rank - expectedRank),
+            costInput: model.cost?.input ?? 0,
+            planPriority: planProviders?.has(model.provider) ? 0 : 1,
+            reputation: score.reputation,
+            surgePenalty: 0,
+        };
+    });
+
+    const filtered = allCandidates.filter((c) => isAllowlisted(c.selector, allowlist) && !c.exhausted);
+    // Dedup: keep only the best model per (provider, tier) group.
+    // This prevents old models in the same tier (e.g. MiniMax-M2, M2.5, M2.7)
+    // from flooding the candidate pool against the latest (M3).
+    const deduped = dedupByProviderTier(filtered);
+    // ── surge pricing penalty ──────────────────────────────────────
+    // Peak-time pricing adjustments + monthly-plan preference.
+    const peak = peakStatus ?? getPeakStatus();
+    const hasMonthlyAvailable = deduped.some(
+        (c) => planProviders?.has(c.model.provider) && !c.exhausted,
+    );
+    for (const c of deduped) {
+        const isDS = c.model.provider === 'deepseek';
+        const isGLM5 = c.model.provider === 'zhipu-coding-plan' && isGLM5Model(c.model.id);
+        let penalty = 0;
+        if (isDS && peak.deepseekPeak) penalty = Math.max(penalty, 2);
+        if (isGLM5 && peak.glm5Peak) penalty = Math.max(penalty, 2);
+        // When any monthly-plan provider has available quota, heavily
+        // penalize DeepSeek (PAYG) to preserve plan budget.
+        if (isDS && hasMonthlyAvailable) penalty = Math.max(penalty, 3);
+        c.surgePenalty = penalty;
+    }
+
+
+
+    let picked: ScoredCandidate | null = null;
+    if (deduped.length > 0) {
+        const sorted = [...deduped].sort((a, b) => {
+            const effA = a.tierGap + a.surgePenalty;
+            const effB = b.tierGap + b.surgePenalty;
+            if (effA !== effB) return effA - effB;
+            if (a.rank !== b.rank) return b.rank - a.rank;
+            // Same effective tier: prefer monthly plan, then cheapest model
+            if (a.planPriority !== b.planPriority) return a.planPriority - b.planPriority;
+            const ar = a.remainingFraction ?? 1;
+            const br = b.remainingFraction ?? 1;
+            if (ar !== br) return br - ar;
+            if (a.costInput !== b.costInput) return a.costInput - b.costInput;
+            if (a.reputation !== b.reputation) return b.reputation - a.reputation;
+            return a.selector.localeCompare(b.selector);
+        });
+        picked = sorted[0] ?? null;
+    }
+    const decision = buildDecisionLog(role, expectedTier, allCandidates, deduped, picked);
+    const pickedReason = picked
+        ? `${picked.selector} (tier=${picked.tier}, gap=${picked.tierGap}${picked.surgePenalty > 0 ? `+${picked.surgePenalty}` : ''})`
+        : null;
+
+    return { role, expectedTier, picked: picked?.model ?? null, candidates: deduped, allCandidates, decision, pickedReason };
+}
+
+function buildDecisionLog(
+    role: string, expectedTier: TierName,
+    all: ScoredCandidate[], filtered: ScoredCandidate[], picked: ScoredCandidate | null,
+): string {
+    const total = all.length;
+    const exhausted = all.filter((c) => c.exhausted).length;
+    if (total === 0) return `role=${role}: no models available`;
+    if (!picked) return `role=${role}: expected tier=${expectedTier}; ${total} scored, ${exhausted} exhausted → none`;
+    return [
+        `role=${role}: expected tier=${expectedTier}`,
+        `${total} available, ${exhausted} exhausted, ${filtered.length} candidates`,
+        `picked=${picked.selector} tier=${picked.tier} gap=${picked.tierGap}`,
+        `reason=${picked.reason}`,
+    ].join(' | ');
+}
+
+export function selectAllRoles(
+    roles: string[], models: Model<Api>[],
+    roleTiers: Record<string, TierName> | undefined,
+    tierOverrides: TierOverride[] | undefined,
+    health: Map<string, ProviderHealth> | undefined,
+    allowlist: string[] | undefined,
+    planProviders?: Set<string>,
+    peakStatus?: PeakStatus,
+): Record<string, SelectorResult> {
+    const out: Record<string, SelectorResult> = {};
+    for (const role of roles) {
+        out[role] = selectModel({ role, models, roleTiers, tierOverrides, health, allowlist, planProviders, peakStatus });
+    }
+    return out;
+}
+
+
+/** One-line description of a selector result, suitable for system prompts. */
+export function formatSelectorForPrompt(result: SelectorResult): string {
+    const { role, expectedTier, picked, pickedReason } = result;
+    if (!picked) return `• ${role}: 无可选 model (期望 tier=${expectedTier})`;
+    return `• ${role}: ${picked.provider}/${picked.id} (tier=${expectedTier}, ${pickedReason})`;
+}

package/lib/model-tiers.ts

@@ -0,0 +1,164 @@
+/**
+ * Model tier scoring.
+ *
+ * A "tier" is a numeric 0..N rank that ranks a model's capability. Higher = stronger.
+ *
+ * Tier resolution uses three layers (highest priority first):
+ *   1. User overrides from `opsx.yml` `tiers:` config
+ *   2. Data-driven lookup from `~/.omp/cache/tiers-data.json`
+ *   3. Heuristic fallback based on model name patterns
+ *
+ * Users can override the score in two ways via `~/.omp/agent/opsx.yml` /
+ * `<cwd>/.omp/opsx.yml`:
+ *
+ *   tiers:
+ *     - pattern: "*opus*"
+ *       tier: top
+ *     - pattern: "deepseek/deepseek-chat"
+ *       tier: high
+ *
+ * Tier names map to numeric ranks via {@link TIER_RANK}. Unknown tier names
+ * fall back to the heuristic score.
+ */
+
+import { matchDataEntry } from './tiers-data.js';
+
+/** Ordered tier names. Higher index = stronger. */
+export const TIER_NAMES = ['tiny', 'low', 'mid', 'high', 'top'] as const;
+export type TierName = (typeof TIER_NAMES)[number];
+
+export const TIER_RANK: Record<TierName, number> = {
+    tiny: 0,
+    low: 1,
+    mid: 2,
+    high: 3,
+    top: 4,
+};
+
+export const DEFAULT_ROLE_TIER: Record<string, TierName> = {
+    coder: 'high',
+    reviewer: 'high',
+    planner: 'high',
+    'proposal-reviewer': 'high',
+};
+
+/** A user override rule from `opsx.yml` `tiers:`. */
+export interface TierOverride {
+    pattern: string;
+    tier: TierName | number;
+}
+
+export interface TierScore {
+    rank: number;
+    tier: TierName;
+    reason: string;
+    /** Coding reputation 0–100, based on generation only (not family). */
+    reputation: number;
+}
+
+export function tierNameToRank(name: TierName | string | number | undefined): number {
+    if (typeof name === 'number') return name;
+    if (typeof name === 'string' && name in TIER_RANK) return TIER_RANK[name as TierName];
+    return 0;
+}
+
+export function rankToTierName(rank: number): TierName {
+    let best: TierName = 'tiny';
+    let bestDist = Infinity;
+    for (const t of TIER_NAMES) {
+        const d = Math.abs(TIER_RANK[t] - rank);
+        if (d < bestDist) { bestDist = d; best = t; }
+    }
+    return best;
+}
+
+/** Reputation based only on model generation (stronger variants = higher reputation). */
+function getReputation(haystack: string): number {
+    let rep = 50; // baseline
+    // Generation bonus — stronger variants boost reputation.
+    if (/\b(opus|ultra|pro\b|k3|glm-?5|5\.0|5\.1|5\.2)\b/i.test(haystack)) rep += 20;
+    else if (/\b(m3|o1|o3|sonnet|thinking|reasoner|gpt-?4|v[3-9]|4\.1|4o|4o-mini)\b/i.test(haystack)) rep += 10;
+    // Extra bonus for k3 over glm (user preference: k3 > glm5.2)
+    if (/\bk3\b/i.test(haystack)) rep += 5;
+    // Generation penalty — weaker variants reduce reputation.
+    if (/\b(haiku|mini|nano|lite|tiny|flash|small|light|k1)\b/i.test(haystack)) rep -= 15;
+    return Math.max(0, Math.min(100, rep));
+}
+
+/** Heuristic tier score from model id + name (fallback when data layer misses). */
+function heuristicScore(modelId: string, modelName?: string): TierScore {
+    const haystack = `${modelName ?? ''} ${modelId}`.toLowerCase();
+    if (!haystack.trim()) return { rank: 0, tier: 'tiny', reason: 'empty identifier', reputation: 0 };
+    if (/\bhaiku\b/.test(haystack)) return { rank: TIER_RANK.low, tier: 'low', reason: 'name contains "haiku"', reputation: getReputation(haystack) };
+    if (/\b(mini|nano|lite|flash-lite|tiny|small)\b/.test(haystack)) return { rank: TIER_RANK.tiny, tier: 'tiny', reason: 'name contains mini/nano/lite/tiny/small', reputation: getReputation(haystack) };
+    if (/\b(opus|gpt-\d[\d.]*-pro|gemini-\d[\d.]*-pro|deep[-_ ]?(think|research)|ultra|\bm3\b|\bm2\b|kimi[._-]?k[23]|glm[._-]?5|codex-pro|o1|o3)\b/.test(haystack)) return { rank: TIER_RANK.top, tier: 'top', reason: 'name contains opus/o1/pro/ultra/M3/M2/kimi-k2-k3/glm-5/codex-pro/o1', reputation: getReputation(haystack) };
+    if (/\b(deepseek[._-]?)?\w+[._-]pro\b/.test(haystack)) return { rank: TIER_RANK.top, tier: 'top', reason: 'name contains "-pro" flagship suffix', reputation: getReputation(haystack) };
+    if (/\b(sonnet|thinking|reasoner)\b/.test(haystack)) return { rank: TIER_RANK.high, tier: 'high', reason: 'name contains sonnet/thinking/reasoner', reputation: getReputation(haystack) };
+    if (/\b(gpt-5|gpt-4\.1|gpt-4o|gpt-4)\b/.test(haystack)) return { rank: TIER_RANK.high, tier: 'high', reason: 'gpt-5/4.x family', reputation: getReputation(haystack) };
+    if (/\b(claude|gpt|gemini|minimax|deepseek|kimi|qwen|glm|llama|mistral|command[-_ ]?r)\b/.test(haystack)) return { rank: TIER_RANK.mid, tier: 'mid', reason: 'known family, no explicit tier signal', reputation: getReputation(haystack) };
+    return { rank: TIER_RANK.mid, tier: 'mid', reason: 'unknown family, defaulting to mid', reputation: 50 };
+}
+
+/**
+ * Tier score from model id + name.
+ * Priority: data layer → heuristic.
+ * opsx.yml overrides are NOT applied here (handled by `scoreModel` / `scoreModelWithProvider`).
+ */
+export function scoreModelByName(modelId: string, modelName?: string): TierScore {
+    const dataMatch = matchDataEntry(modelId);
+    if (dataMatch) {
+        return {
+            rank: tierNameToRank(dataMatch.tier),
+            tier: dataMatch.tier,
+            reason: dataMatch.reason,
+            reputation: dataMatch.reputation,
+        };
+    }
+    return heuristicScore(modelId, modelName);
+}
+
+function globToRegex(pattern: string): RegExp {
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.');
+    return new RegExp(`^${escaped}$`, 'i');
+}
+
+/** Apply user overrides to a score. First matching override wins. */
+export function applyTierOverrides(
+    selector: string,
+    base: TierScore,
+    overrides?: TierOverride[],
+): TierScore {
+    if (!overrides?.length) return base;
+    for (const rule of overrides) {
+        if (globToRegex(rule.pattern).test(selector)) {
+            const rank = tierNameToRank(rule.tier);
+            return { rank, tier: rankToTierName(rank), reason: `override: ${rule.pattern} → ${rule.tier}`, reputation: base.reputation };
+        }
+    }
+    return base;
+}
+
+/** Score a model given its id, name, and any user overrides. */
+export function scoreModel(
+    modelId: string,
+    modelName: string | undefined,
+    overrides?: TierOverride[],
+): TierScore {
+    const base = scoreModelByName(modelId, modelName);
+    return applyTierOverrides(modelId, base, overrides);
+}
+
+/** Score a model given its provider + id (so `provider/modelId` overrides work). */
+export function scoreModelWithProvider(
+    provider: string,
+    modelId: string,
+    modelName: string | undefined,
+    overrides?: TierOverride[],
+): TierScore {
+    // Provider-scoped data match has higher priority than bare-id heuristic
+    const dataMatch = matchDataEntry(modelId, provider);
+    const base = dataMatch
+        ? { rank: tierNameToRank(dataMatch.tier), tier: dataMatch.tier, reason: dataMatch.reason, reputation: dataMatch.reputation }
+        : scoreModelByName(modelId, modelName);
+    return applyTierOverrides(`${provider}/${modelId}`, base, overrides);
+}

package/lib/notify.ts

@@ -0,0 +1,4 @@
+export function notify(title: string, message: string): void {
+    const safe = (s: string) => s.replace(/;/g, '：');
+    process.stderr.write(`\x1b]777;notify;${safe(title)};${safe(message)}\x07`);
+}

package/lib/openspec-tasks.ts

@@ -0,0 +1,28 @@
+import { readFile } from 'fs/promises';
+import { join } from 'path';
+
+/** Shared task checkbox parsing for openspec change tasks.md files */
+export function countTaskCheckboxes(content: string): { completed: number; total: number } {
+    let completed = 0;
+    let total = 0;
+    for (const line of content.split('\n')) {
+        if (/^\s*- \[x\]/i.test(line)) {
+            completed++;
+            total++;
+        } else if (/^\s*- \[ \]/.test(line)) {
+            total++;
+        }
+    }
+    return { completed, total };
+}
+
+export async function countTasks(dir: string, name: string): Promise<{ current: number; total: number } | null> {
+    const path = join(dir, 'openspec', 'changes', name, 'tasks.md');
+    try {
+        const content = await readFile(path, 'utf-8');
+        const { completed, total } = countTaskCheckboxes(content);
+        return total > 0 ? { current: completed, total } : null;
+    } catch {
+        return null;
+    }
+}

package/lib/peak-detector.ts

@@ -0,0 +1,44 @@
+/**
+ * Peak-time detection for model surge pricing.
+ *
+ * DeepSeek peak: 9:00-12:00 and 14:00-18:00 Beijing time (UTC+8), all days.
+ * GLM-5 peak:   Mon-Fri 14:00-18:00 Beijing time (UTC+8).
+ */
+
+export interface PeakStatus {
+  /** DeepSeek peak: 9:00-12:00 or 14:00-18:00 Beijing time, all days. */
+  deepseekPeak: boolean;
+  /** GLM-5 peak: Mon-Fri 14:00-18:00 Beijing time. */
+  glm5Peak: boolean;
+}
+
+const BEIJING_OFFSET_MS = 8 * 60 * 60 * 1000; // UTC+8
+
+function beijingTime(d: Date): { hour: number; day: number } {
+  const utcMs = d.getTime() + d.getTimezoneOffset() * 60 * 1000;
+  const bjMs = utcMs + BEIJING_OFFSET_MS;
+  const bjDate = new Date(bjMs);
+  return { hour: bjDate.getUTCHours(), day: bjDate.getUTCDay() };
+}
+
+/**
+ * Determine current peak pricing windows.
+ * @param now — current time (injectable for testing).
+ */
+export function getPeakStatus(now: Date = new Date()): PeakStatus {
+  const { hour, day } = beijingTime(now);
+
+  // DeepSeek peak: 9:00-12:00 (inclusive start, exclusive end) or 14:00-18:00
+  const deepseekPeak = (hour >= 9 && hour < 12) || (hour >= 14 && hour < 18);
+
+  // GLM-5 peak: Mon(1)-Fri(5) 14:00-18:00
+  const isWeekday = day >= 1 && day <= 5;
+  const glm5Peak = isWeekday && hour >= 14 && hour < 18;
+
+  return { deepseekPeak, glm5Peak };
+}
+
+/** Check if a model belongs to the GLM-5 family. */
+export function isGLM5Model(modelId: string): boolean {
+  return /glm[._-]?5(?![0-9])/i.test(modelId);
+}