oc-deepseek-pricing 0.0.0-stage → 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 scicco
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,210 @@
-# Temporary Holding Version
+# oc-deepseek-pricing
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+An OpenCode v2 TUI plugin that displays the current DeepSeek API pricing window in the prompt footer and session sidebar.
+
+The indicator is intended for the direct DeepSeek provider. DeepSeek off-peak rates are half of peak rates.
+
+## Features
+
+- Displays the current pricing window in the prompt footer.
+- Displays pricing details in the session sidebar.
+- Distinguishes peak and off-peak periods.
+- Shows the next pricing transition and a countdown.
+- Treats weekends as fully off-peak.
+- Supports Chinese public-holiday overrides.
+- Warns when the holiday calendar does not cover the current Chinese calendar year.
+- Uses local computation only; no network request is needed at runtime.
+
+## Pricing schedule
+
+Peak windows are evaluated in UTC:
+
+- `01:00-04:00 UTC`, Monday through Friday.
+- `06:00-10:00 UTC`, Monday through Friday.
+
+All other times are off-peak, including:
+
+- `04:00-06:00 UTC` on weekdays;
+- all hours after `10:00 UTC` and before `01:00 UTC`;
+- Saturdays and Sundays in full;
+- Chinese public holidays in full.
+
+The off-peak price multiplier is `0.5`.
+
+## Requirements
+
+- OpenCode v2 with TUI plugin support.
+- Bun.
+- A terminal supported by OpenCode.
+
+Development dependencies include:
+
+- `@opencode/plugin`;
+- `@opentui/core`;
+- `@opentui/solid`;
+- `solid-js`;
+- TypeScript.
+
+## Repository structure
+
+```text
+oc-deepseek-pricing/
+├── CALENDAR_UPDATE.md
+├── README.md
+├── bun.lock
+├── package.json
+├── src/
+│   ├── holidays.ts
+│   ├── pricing.test.ts
+│   ├── pricing.ts
+│   └── tui.tsx
+└── tsconfig.json
+```
+
+## Development setup
+
+Install dependencies:
+
+```sh
+bun install
+```
+
+Run the TypeScript check:
+
+```sh
+bun check
+```
+
+Run the test suite:
+
+```sh
+bun test
+```
+
+A successful validation should complete without TypeScript errors and with all pricing tests passing.
+
+## OpenCode CLI configuration
+
+Register the local TUI package in:
+
+```text
+~/.config/opencode/cli.json
+```
+
+Keep existing plugins and add `./plugins/oc-deepseek-pricing` to the `plugins` array.
+
+Example:
+
+```json
+{
+  "diffs": {
+    "wrap": "word",
+    "fullscreen": true
+  },
+  "session": {
+    "sidebar": "auto",
+    "scrollbar": false,
+    "thinking": "hide"
+  },
+  "animations": true,
+  "plugins": ["./herdr-opencode", "./plugins/oc-deepseek-pricing"]
+}
+```
+
+Relative paths are resolved from the OpenCode configuration directory.
+
+The package exposes its TUI entrypoint through `package.json`:
+
+```json
+{
+  "exports": {
+    "./tui": "./src/tui.tsx"
+  }
+}
+```
+
+The legacy or integration-specific `tui.jsonc` file does not need to contain this plugin when the package is loaded through `cli.json`.
+
+## Restarting OpenCode
+
+After changing the plugin source or configuration, close the OpenCode TUI completely and start it again.
+
+Opening a new conversation is not necessarily sufficient because plugin entrypoints are loaded during TUI startup.
+
+## Expected interface
+
+When loaded, the prompt footer displays a compact indicator similar to:
+
+```text
+DeepSeek: OFF-PEAK 50% · PEAK in 11h 36m
+```
+
+During a peak window it displays a value similar to:
+
+```text
+DeepSeek: PEAK · OFF-PEAK 50% in 1h 15m
+```
+
+The session sidebar displays details similar to:
+
+```text
+DeepSeek pricing
+Status OFF-PEAK 50%
+Reason outside peak windows
+Next PEAK in 11h 36m
+At 10/28/2026, 2:00:00 AM
+China 2026-10-27
+```
+
+The exact local transition time depends on the operating-system timezone and daylight-saving rules. Pricing classification itself is based on UTC, while holiday lookup uses the `Asia/Shanghai` calendar date.
+
+## Chinese public holidays
+
+The holiday data is stored in:
+
+```text
+src/holidays.ts
+```
+
+Only officially verified calendar years should be added to `COVERED_HOLIDAY_YEARS`.
+
+For the full annual update procedure, source requirements, timezone rules, validation checklist, and required tests, see [CALENDAR_UPDATE.md](./CALENDAR_UPDATE.md).
+
+If the current Chinese calendar year is not covered, the plugin continues to apply the normal UTC weekday and weekend schedule but displays a coverage warning. Do not suppress the warning by adding a year without adding and reviewing the complete official calendar.
+
+## Tests
+
+The test suite covers:
+
+- the first weekday peak window;
+- the off-peak gap between the two peak windows;
+- the second weekday peak window;
+- exact peak-window boundaries;
+- weekends;
+- ordinary weekday off-peak periods;
+- Chinese public-holiday overrides;
+- calendar-year coverage;
+- next-transition calculation;
+- weekend skipping when finding the next peak period;
+- duration formatting;
+- invalid date handling.
+
+Run:
+
+```sh
+bun test
+```
+
+## Type checking
+
+Run:
+
+```sh
+bun check
+```
+
+The repository uses `NodeNext` module resolution. Relative TypeScript imports must therefore use the emitted JavaScript extension, for example:
+
+```ts
+import { getPricingSnapshot } from "./pricing.js"
+```

package/package.json

@@ -1,6 +1,61 @@
 {
   "name": "oc-deepseek-pricing",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "OpenCode TUI plugin showing DeepSeek peak and off-peak pricing windows",
+  "type": "module",
+  "license": "MIT",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "deepseek",
+    "pricing",
+    "tui"
+  ],
+  "files": [
+    "src",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    "./tui": "./src/tui.tsx"
+  },
+  "opencode": {
+    "tui": "./src/tui.tsx"
+  },
+  "scripts": {
+    "test": "bun test",
+    "check": "bun run format:check && bun run lint && bun run typecheck && bun test",
+    "format": "biome format --write .",
+    "format:check": "biome format .",
+    "lint": "biome lint .",
+    "lint:fix": "biome lint --write .",
+    "biome:check": "biome check .",
+    "biome:fix": "biome check --write .",
+    "typecheck": "tsc --noEmit",
+    "pack:check": "npm pack --dry-run",
+    "prepublishOnly": "bun run check"
+  },
+  "peerDependencies": {
+    "@opencode/plugin": ">=2.2.0 <2.3.0",
+    "@opentui/core": "0.7.x",
+    "@opentui/solid": "0.7.x",
+    "solid-js": "1.9.17"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "2.6.3",
+    "@opencode/plugin": "2.2.0",
+    "@opentui/core": "0.7.0",
+    "@opentui/solid": "0.7.0",
+    "@types/bun": "1.4.4",
+    "solid-js": "1.9.17",
+    "typescript": "5.9.3"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/scicco/oc-deepseek-pricing.git"
+  },
+  "bugs": {
+    "url": "https://github.com/scicco/oc-deepseek-pricing/issues"
+  },
+  "homepage": "https://github.com/scicco/oc-deepseek-pricing#readme"
+}

package/src/holidays.ts

@@ -0,0 +1,56 @@
+// Official public-holiday periods published by the General Office of the
+// State Council of the People's Republic of China.
+//
+// Dates use the Asia/Shanghai calendar and ISO YYYY-MM-DD format.
+// Compensatory working weekends are intentionally not listed: DeepSeek's
+// pricing rule explicitly treats all Saturdays and Sundays as off-peak.
+export const CHINESE_PUBLIC_HOLIDAYS = new Set<string>([
+  // 2026 New Year's Day: January 1-3
+  "2026-01-01",
+  "2026-01-02",
+  "2026-01-03",
+
+  // 2026 Spring Festival: February 15-23
+  "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 Qingming Festival: April 4-6
+  "2026-04-04",
+  "2026-04-05",
+  "2026-04-06",
+
+  // 2026 Labor Day: May 1-5
+  "2026-05-01",
+  "2026-05-02",
+  "2026-05-03",
+  "2026-05-04",
+  "2026-05-05",
+
+  // 2026 Dragon Boat Festival: June 19-21
+  "2026-06-19",
+  "2026-06-20",
+  "2026-06-21",
+
+  // 2026 Mid-Autumn Festival: September 25-27
+  "2026-09-25",
+  "2026-09-26",
+  "2026-09-27",
+
+  // 2026 National Day: October 1-7
+  "2026-10-01",
+  "2026-10-02",
+  "2026-10-03",
+  "2026-10-04",
+  "2026-10-05",
+  "2026-10-06",
+  "2026-10-07",
+])
+
+export const COVERED_HOLIDAY_YEARS = new Set<number>([2026])

package/src/pricing.test.ts

@@ -0,0 +1,121 @@
+import { describe, expect, test } from "bun:test"
+
+import { formatDuration, getPricingSnapshot } from "./pricing.js"
+
+const COVERED_YEARS = new Set([2026])
+
+function snapshotAt(iso: string, holidays: ReadonlySet<string> = new Set()) {
+  return getPricingSnapshot(new Date(iso), {
+    chinesePublicHolidays: holidays,
+    coveredHolidayYears: COVERED_YEARS,
+  })
+}
+
+function stateAt(iso: string) {
+  return snapshotAt(iso).state
+}
+
+describe("pricing windows", () => {
+  test("handles both weekday peak windows", () => {
+    expect(stateAt("2026-10-26T00:59:59Z")).toBe("off-peak")
+    expect(stateAt("2026-10-26T01:00:00Z")).toBe("peak")
+    expect(stateAt("2026-10-26T04:00:00Z")).toBe("off-peak")
+    expect(stateAt("2026-10-26T06:00:00Z")).toBe("peak")
+    expect(stateAt("2026-10-26T10:00:00Z")).toBe("off-peak")
+  })
+
+  test("keeps weekends off-peak", () => {
+    const saturday = snapshotAt("2026-10-24T02:00:00Z")
+    const sunday = snapshotAt("2026-10-25T07:00:00Z")
+
+    expect(saturday.state).toBe("off-peak")
+    expect(saturday.reason).toBe("weekend")
+
+    expect(sunday.state).toBe("off-peak")
+    expect(sunday.reason).toBe("weekend")
+  })
+
+  test("marks ordinary weekday hours outside the windows as off-peak", () => {
+    const snapshot = snapshotAt("2026-10-26T05:00:00Z")
+
+    expect(snapshot.state).toBe("off-peak")
+    expect(snapshot.reason).toBe("outside-peak-window")
+    expect(snapshot.rateMultiplier).toBe(0.5)
+  })
+
+  test("uses the full multiplier during peak hours", () => {
+    const snapshot = snapshotAt("2026-10-26T08:00:00Z")
+
+    expect(snapshot.state).toBe("peak")
+    expect(snapshot.reason).toBe("peak-window")
+    expect(snapshot.rateMultiplier).toBe(1)
+  })
+})
+
+describe("Chinese public holidays", () => {
+  test("overrides a weekday peak window", () => {
+    const snapshot = snapshotAt("2026-10-01T02:00:00Z", new Set(["2026-10-01"]))
+
+    expect(snapshot.state).toBe("off-peak")
+    expect(snapshot.reason).toBe("chinese-public-holiday")
+    expect(snapshot.rateMultiplier).toBe(0.5)
+  })
+
+  test("reports whether the Chinese calendar year is covered", () => {
+    expect(snapshotAt("2026-10-27T12:00:00Z").holidayCalendarCovered).toBe(true)
+
+    const uncovered = getPricingSnapshot(new Date("2027-01-05T12:00:00Z"), {
+      chinesePublicHolidays: new Set(),
+      coveredHolidayYears: COVERED_YEARS,
+    })
+
+    expect(uncovered.holidayCalendarCovered).toBe(false)
+  })
+})
+
+describe("next transition", () => {
+  test("finds the end of the first peak window", () => {
+    const snapshot = snapshotAt("2026-10-27T02:15:00Z")
+
+    expect(snapshot.nextState).toBe("off-peak")
+    expect(snapshot.nextTransition).toBe("2026-10-27T04:00:00.000Z")
+    expect(snapshot.secondsUntilTransition).toBe(6_300)
+  })
+
+  test("finds the beginning of the second peak window", () => {
+    const snapshot = snapshotAt("2026-10-27T05:30:00Z")
+
+    expect(snapshot.nextState).toBe("peak")
+    expect(snapshot.nextTransition).toBe("2026-10-27T06:00:00.000Z")
+    expect(snapshot.secondsUntilTransition).toBe(1_800)
+  })
+
+  test("skips the weekend when finding the next peak window", () => {
+    const snapshot = snapshotAt("2026-10-30T10:00:00Z")
+
+    expect(snapshot.state).toBe("off-peak")
+    expect(snapshot.nextState).toBe("peak")
+    expect(snapshot.nextTransition).toBe("2026-11-02T01:00:00.000Z")
+  })
+})
+
+describe("duration formatting", () => {
+  test("formats minutes and hours", () => {
+    expect(formatDuration(60)).toBe("1m")
+    expect(formatDuration(3_600)).toBe("1h")
+    expect(formatDuration(5_400)).toBe("1h 30m")
+  })
+
+  test("rounds partial minutes up", () => {
+    expect(formatDuration(1)).toBe("1m")
+    expect(formatDuration(61)).toBe("2m")
+  })
+})
+
+describe("input validation", () => {
+  test("rejects invalid dates", () => {
+    expect(() => {
+      getPricingSnapshot(new Date("invalid"))
+    }).toThrow("Invalid date")
+  })
+})

package/src/pricing.ts

@@ -0,0 +1,98 @@
+export type PricingState = "peak" | "off-peak"
+export type PricingReason =
+  | "peak-window"
+  | "outside-peak-window"
+  | "weekend"
+  | "chinese-public-holiday"
+
+export interface PricingSnapshot {
+  state: PricingState
+  rateMultiplier: 1 | 0.5
+  reason: PricingReason
+  now: string
+  nextTransition: string
+  nextState: PricingState
+  secondsUntilTransition: number
+  holidayCalendarCovered: boolean
+  chinaDate: string
+}
+
+export interface PricingOptions {
+  chinesePublicHolidays?: ReadonlySet<string>
+  coveredHolidayYears?: ReadonlySet<number>
+}
+
+const PEAK_WINDOWS = [
+  { startHour: 1, endHour: 4 },
+  { startHour: 6, endHour: 10 },
+] as const
+const CHINA_DATE_FORMATTER = new Intl.DateTimeFormat("en-CA", {
+  timeZone: "Asia/Shanghai",
+  year: "numeric",
+  month: "2-digit",
+  day: "2-digit",
+})
+
+function chinaDate(date: Date): string {
+  return CHINA_DATE_FORMATTER.format(date)
+}
+function isWeekday(date: Date): boolean {
+  const day = date.getUTCDay()
+  return day >= 1 && day <= 5
+}
+function isInsidePeakWindow(date: Date): boolean {
+  const hour = date.getUTCHours() + date.getUTCMinutes() / 60 + date.getUTCSeconds() / 3600
+  return PEAK_WINDOWS.some(({ startHour, endHour }) => hour >= startHour && hour < endHour)
+}
+function classify(
+  date: Date,
+  holidays: ReadonlySet<string>,
+): { state: PricingState; reason: PricingReason } {
+  if (holidays.has(chinaDate(date))) return { state: "off-peak", reason: "chinese-public-holiday" }
+  if (!isWeekday(date)) return { state: "off-peak", reason: "weekend" }
+  if (isInsidePeakWindow(date)) return { state: "peak", reason: "peak-window" }
+  return { state: "off-peak", reason: "outside-peak-window" }
+}
+function nextTransition(date: Date, holidays: ReadonlySet<string>): Date {
+  const current = classify(date, holidays).state
+  const cursor = new Date(date)
+  cursor.setUTCMilliseconds(0)
+  cursor.setUTCSeconds(0)
+  cursor.setUTCMinutes(0)
+  if (cursor.getTime() <= date.getTime()) cursor.setUTCHours(cursor.getUTCHours() + 1)
+  for (let i = 0; i < 24 * 14; i += 1) {
+    if (classify(cursor, holidays).state !== current) return cursor
+    cursor.setUTCHours(cursor.getUTCHours() + 1)
+  }
+  throw new Error("Unable to find the next DeepSeek pricing transition within 14 days")
+}
+export function getPricingSnapshot(
+  date = new Date(),
+  options: PricingOptions = {},
+): PricingSnapshot {
+  if (Number.isNaN(date.getTime())) throw new TypeError("Invalid date")
+  const holidays = options.chinesePublicHolidays ?? new Set<string>()
+  const coveredYears = options.coveredHolidayYears ?? new Set<number>()
+  const current = classify(date, holidays)
+  const transition = nextTransition(date, holidays)
+  const chinaDay = chinaDate(date)
+  return {
+    state: current.state,
+    rateMultiplier: current.state === "peak" ? 1 : 0.5,
+    reason: current.reason,
+    now: date.toISOString(),
+    nextTransition: transition.toISOString(),
+    nextState: current.state === "peak" ? "off-peak" : "peak",
+    secondsUntilTransition: Math.max(0, Math.ceil((transition.getTime() - date.getTime()) / 1000)),
+    holidayCalendarCovered: coveredYears.has(Number(chinaDay.slice(0, 4))),
+    chinaDate: chinaDay,
+  }
+}
+export function formatDuration(totalSeconds: number): string {
+  const minutes = Math.max(0, Math.ceil(totalSeconds / 60))
+  const hours = Math.floor(minutes / 60)
+  const rest = minutes % 60
+  if (hours === 0) return `${rest}m`
+  if (rest === 0) return `${hours}h`
+  return `${hours}h ${rest}m`
+}

package/src/tui.tsx

@@ -0,0 +1,235 @@
+/** @jsxImportSource @opentui/solid */
+
+import { Plugin } from "@opencode/plugin/tui"
+import { createSignal } from "solid-js"
+import { CHINESE_PUBLIC_HOLIDAYS, COVERED_HOLIDAY_YEARS } from "./holidays.js"
+import {
+  formatDuration,
+  getPricingSnapshot,
+  type PricingReason,
+  type PricingSnapshot,
+  type PricingState,
+} from "./pricing.js"
+
+function createSnapshot(): PricingSnapshot {
+  return getPricingSnapshot(new Date(), {
+    chinesePublicHolidays: CHINESE_PUBLIC_HOLIDAYS,
+    coveredHolidayYears: COVERED_HOLIDAY_YEARS,
+  })
+}
+
+function stateLabel(state: PricingState): string {
+  return state === "peak" ? "🐳 peak" : "🐋💤 off-peak"
+}
+
+function stateName(state: PricingState): string {
+  return state === "peak" ? "peak" : "off-peak"
+}
+
+function StateLabel(props: { state: PricingState }) {
+  if (props.state === "peak") {
+    return <text>🐳 peak</text>
+  }
+
+  return (
+    <box flexDirection="row">
+      <text>🐋💤 </text>
+      <text fg="gray">off-peak</text>
+    </box>
+  )
+}
+
+function reasonLabel(reason: PricingReason): string {
+  switch (reason) {
+    case "peak-window":
+      return "weekday peak window"
+    case "outside-peak-window":
+      return "outside peak windows"
+    case "weekend":
+      return "weekend"
+    case "chinese-public-holiday":
+      return "Chinese public holiday"
+  }
+}
+
+function formatLocalTransition(snapshot: PricingSnapshot): string {
+  return new Date(snapshot.nextTransition).toLocaleString()
+}
+
+function isDeepSeekSelected(
+  model:
+    | {
+        readonly providerID: string
+        readonly modelID: string
+        readonly variant?: string
+      }
+    | undefined,
+): boolean {
+  return model?.modelID.toLowerCase().includes("deepseek") ?? false
+}
+
+export default Plugin.define({
+  id: "oc-deepseek-pricing",
+
+  setup(ctx) {
+    const [snapshot, setSnapshot] = createSignal(createSnapshot())
+
+    let transitionTimer: ReturnType<typeof setTimeout> | undefined
+    let minuteTimer: ReturnType<typeof setInterval> | undefined
+
+    const refresh = (): PricingSnapshot => {
+      const updated = createSnapshot()
+      setSnapshot(updated)
+      return updated
+    }
+
+    const scheduleTransition = (): void => {
+      if (transitionTimer !== undefined) {
+        clearTimeout(transitionTimer)
+      }
+
+      const current = snapshot()
+      const delay = Math.max(1_000, current.secondsUntilTransition * 1_000 + 250)
+
+      transitionTimer = setTimeout(() => {
+        refresh()
+        scheduleTransition()
+      }, delay)
+    }
+
+    const showStatus = (): void => {
+      const current = refresh()
+
+      const lines = [
+        `Status ${stateLabel(current.state)}`,
+        `Reason ${reasonLabel(current.reason)}`,
+        `Next ${stateName(current.nextState)} in ${formatDuration(current.secondsUntilTransition)}`,
+        `At ${formatLocalTransition(current)}`,
+        `China ${current.chinaDate}`,
+      ]
+
+      if (!current.holidayCalendarCovered) {
+        lines.push("Warning: Chinese holiday calendar is not configured for this year")
+      }
+
+      ctx.ui.toast.show({
+        title: "DeepSeek pricing",
+        message: lines.join("\n"),
+        variant: current.state === "peak" ? "warning" : "success",
+      })
+    }
+
+    const removePromptFooter = ctx.ui.slot({
+      append: "prompt.footer.status",
+
+      render() {
+        const model = ctx.ui.model.current()
+
+        if (!isDeepSeekSelected(model)) {
+          return null
+        }
+
+        const current = snapshot()
+
+        return (
+          <box flexDirection="row">
+            <StateLabel state={current.state} />
+            <text>
+              {" · "}
+              {formatDuration(current.secondsUntilTransition)} left
+            </text>
+          </box>
+        )
+      },
+    })
+
+    const removeHomeFooter = ctx.ui.slot({
+      append: "home.footer.status",
+
+      render() {
+        const model = ctx.ui.model.current()
+
+        if (!isDeepSeekSelected(model)) {
+          return null
+        }
+
+        const current = snapshot()
+
+        return (
+          <box flexDirection="row">
+            <StateLabel state={current.state} />
+            <text>
+              {" · "}
+              {formatDuration(current.secondsUntilTransition)} left
+            </text>
+          </box>
+        )
+      },
+    })
+
+    const removeSidebar = ctx.ui.slot({
+      append: "sidebar.content",
+
+      render() {
+        const model = ctx.ui.model.current()
+
+        if (!isDeepSeekSelected(model)) {
+          return null
+        }
+
+        const current = snapshot()
+
+        return (
+          <box flexDirection="column">
+            <box flexDirection="row">
+              <text>Status </text>
+              <StateLabel state={current.state} />
+            </box>
+            <text>{formatDuration(current.secondsUntilTransition)} left</text>
+          </box>
+        )
+      },
+    })
+
+    ctx.keymap.layer(() => ({
+      mode: "global",
+      commands: [
+        {
+          id: "deepseek-pricing.status",
+          title: "DeepSeek pricing status",
+          description: "Show the current DeepSeek peak or off-peak pricing window",
+          group: "DeepSeek",
+          enabled: () => isDeepSeekSelected(ctx.ui.model.current()),
+          palette: true,
+          slash: {
+            name: "deepseek-pricing",
+            aliases: ["deepseek-price"],
+          },
+          run: async () => {
+            showStatus()
+          },
+        },
+      ],
+    }))
+
+    minuteTimer = setInterval(() => {
+      refresh()
+    }, 60_000)
+
+    scheduleTransition()
+
+    return () => {
+      if (transitionTimer !== undefined) {
+        clearTimeout(transitionTimer)
+      }
+
+      if (minuteTimer !== undefined) {
+        clearInterval(minuteTimer)
+      }
+
+      removePromptFooter()
+      removeHomeFooter()
+      removeSidebar()
+    }
+  },
+})