@goodandready/dsh-cost-meter 0.7.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 goodandready
+
+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

@@ -0,0 +1,132 @@
+# dsh-cost-meter
+
+Чип стоимости сессии в шапке диалога DeepSeek Harness: живой расход по токенам,
+текущий тариф (пик / не-пик) и обратный отсчёт до его смены.
+
+```
+● ≈ ₽8.55  0:17     ← чип в conversation.session.header.utilities
+```
+
+По клику раскрывается панель: тарифная таблица за 1M токенов в двух колонках
+(не-пик / пик, активная выделена), окна пика в UTC и итог за сессию.
+
+## Откуда берутся цифры
+
+**Токены** — из собственной проекции сессии `costByModel`, которую плагин
+регистрирует тем же механизмом, что и штатный `@deepseek-ai/dsh-token-meter`.
+В журнале есть всё нужное: `request/header` несёт `config: {provider, model}`,
+а usage приходит следом за тем же шагом, поэтому каждая выборка относится к
+модели, которая её заработала.
+
+Накопление идёт не одной кучей, а по **получасовым слотам суток UTC**: расход
+фиксируется по ставке, действовавшей в момент трат, и переключение тарифа не
+пересчитывает уже потраченное. Все реальные окна выровнены по получасу, так что
+слот воспроизводит ставку точно.
+
+Сессионный слот отдаёт компоненту `useProjection`, поэтому значения обновляются
+прямо во время стрима, без опроса.
+
+**Цены** берутся из трёх источников, в таком порядке:
+
+1. **Ручные `prices`** из конфига — для подписок и локальных моделей.
+2. **Официальный прайс DeepSeek** — по имени модели, а не по провайдеру:
+   `deepseek-v4-flash` стоит столько, сколько объявил DeepSeek, кто бы её ни
+   маршрутизировал, а суффиксы версий (`deepseek-v4-flash:0731`) сводятся к той
+   же модели. Таблица зашита в плагин: у DeepSeek нет эндпоинта с
+   ценами (`/models` отдаёт только id, `/pricing` — 404), а записи `deepseek/*`
+   в OpenRouter — это чужой хостинг с другими ставками. Тариф двухуровневый:
+   пик 01:00–04:00 и 06:00–10:00 UTC, вне окон — ровно половина.
+3. **Каталог OpenRouter** (`https://openrouter.ai/api/v1/models`, без ключа) —
+   для всех остальных. Оттуда четыре ставки (`prompt`, `completion`,
+   `input_cache_read`, `input_cache_write`) и, если есть, `pricing.overrides` —
+   окна скидок по времени суток. Каталог кэшируется на диск и обновляется раз в
+   сутки; без сети работает последний кэш.
+
+Если модель не нашлась нигде, виджет пишет «тариф ?» и объясняет, что делать,
+вместо того чтобы показать правдоподобный ноль.
+
+Сам харнесс цен не знает и знать не хочет: у pi-ai есть поле `cost`, но оно
+занулено, и в коде прямо сказано, что ни один потребитель не отчитывается о
+тратах. Поэтому источник — внешний.
+
+**Тариф** вычисляется на клиенте по часам UTC: активная ставка = подходящее
+окно, иначе базовая. Если окон два — таблица показывает обе колонки, активная
+подсвечена, рядом обратный отсчёт до смены. Часы выводятся в зоне
+`displayTimeZone` (по умолчанию московской) через `Intl`, так что переход на
+летнее время учитывается. Если окон нет — одна колонка «ставка» без подсветки.
+
+## Установка из приватного registry
+
+```bash
+dsh plugin --profile web add @goodandready/dsh-cost-meter
+sudo systemctl restart dsh-web
+```
+
+Пакет публикуется в приватный GitHub Packages registry. Исходная разработка,
+изолированная проверка и production-установка выполняются через Git и пакетный
+маршрут; локальные установки из исходного checkout не являются поддерживаемым
+способом развёртывания.
+
+## Конфигурация
+
+| Поле | По умолчанию | Значение |
+|---|---|---|
+| `currency` | `$` | символ валюты в чипе |
+| `usdRate` | `1` | сколько единиц валюты в одном USD; `1` — считать в долларах |
+| `useOpenRouter` | `true` | тянуть ставки и окна скидок из каталога |
+| `displayTimeZone` | `Europe/Moscow` | в какой зоне показывать часы тарифа |
+| `deepseekPeakPrices` | `{}` | переопределить встроенные пиковые ставки DeepSeek |
+| `refreshHours` | `24` | как часто обновлять каталог |
+| `modelMap` | `{}` | сопоставление `провайдер/модель` → id модели в OpenRouter |
+| `prices` | `{}` | ручные ставки по ключу `провайдер/модель` (или `*`); **перекрывают каталог** |
+| `manualPeakWindowsUtc` | `[]` | окна пика `HH:MM-HH:MM` UTC — только для ручных ставок |
+| `manualOffPeakMultiplier` | `1` | множитель вне окон — только для ручных ставок |
+
+Обычно хватает валюты и курса:
+
+```yaml
+- id: dsh-cost-meter
+  config:
+    currency: '₽'
+    usdRate: 80
+```
+
+Модель сопоставляется с каталогом по точному id, затем по суффиксу:
+`deepseek-official/deepseek-v4-flash` → `deepseek/deepseek-v4-flash`. Если
+угадано неверно или модели в каталоге нет — либо `modelMap`, либо ручные ставки:
+
+```yaml
+    modelMap:
+      'ollama/glm-5.2': 'z-ai/glm-5.2'
+    prices:
+      'opencode-go/minimax-m3':      # подписка — считать бесплатным
+        cacheHit: 0
+        input: 0
+        cacheWrite: 0
+        output: 0
+```
+
+## Ограничения
+
+- Модель DeepSeek, вызванная **через OpenRouter**, всё равно считается по
+  официальному прайсу DeepSeek, хотя счёт выставит OpenRouter. Помечено в коде.
+- Данные приходят из usage, который присылает провайдер. Маршруты, не
+  сообщающие usage, дадут нули: в панели об этом сказано явно.
+- Модели, для которых тариф не нашёлся, показываются отдельной строкой и в
+  сумму не входят — сумма честно неполная, а не занижена молча.
+- Курс валюты — константа `usdRate`, живого курса плагин не тянет.
+
+## Устройство
+
+| Файл | Что делает |
+|---|---|
+| `lib/index.js` | конфиг, проекция `costByModel`, тарифы, маршрут `GET /dsh-cost-meter/state` |
+| `lib/client.js` | чип и панель; читает проекцию, считает арифметику по слотам |
+| `cordis.patch.yml` | строка плагина в дереве загрузчика профиля |
+
+Хост не вешает ни одного хука на ход агента — виджет только читает. Плагин,
+который ничего не инжектит в сессию, не может её испортить.
+
+## Лицензия
+
+MIT

package/cordis.patch.yml

@@ -0,0 +1,14 @@
+# dsh-cost-meter bundle layer: inserts the plugin row into the profile's
+# loader tree. Applied automatically because package.json declares
+# `dsh.bundle.patch`. Prices and tariff windows are editable from the Web GUI
+# (Settings -> Cost Meter) or here, e.g.:
+#
+#   - id: dsh-cost-meter
+#     config:
+#       currency: '$'
+#       usdRate: 1
+#
+- insert:
+    - id: dsh-cost-meter
+      name: '@goodandready/dsh-cost-meter'
+      config: {}

package/docs/deployment/public-release.md

@@ -0,0 +1,9 @@
+# Публичный релиз и deployment
+
+Релизная версия повышается patch-изменением (v0.7.3). После merge в `main`
+создаются annotated tag, пакет в npm (`@goodandready/dsh-cost-meter`) и
+публичный GitHub release в `GooDAnDReaDY/dsh-cost-meter`.
+
+Production должен содержать exact package version из npm и не должен иметь
+локальной зависимости на исходный checkout. После restart проверяются
+service health, browser loader и `GET /dsh-cost-meter/state`.

package/docs/design/DESIGN.md

@@ -0,0 +1,82 @@
+# DESIGN.md — dsh-cost-meter
+
+## Product / Purpose
+- Назначение: Отображение стоимости активной сессии диалога в реальном времени, тарифов (пик / не-пик / единый) за 1M токенов, обратного отсчёта до смены окна и прозрачной детализации расходов по каждой задействованной модели.
+- Аудитория: Пользователи и инженеры DeepSeek Harness, контролирующие потребление токенов и бюджет на LLM-провайдеров.
+- Статус: Активная публичная поставка (@goodandready/dsh-cost-meter).
+
+## User Surfaces
+- Web/UI:
+  - Компактный чип в слоте `conversation.session.header.utilities` (order: 10).
+  - Выпадающая панель детализации (width: 320px, absolute positioning, click-outside dismissal).
+- DSH UI / settings / slots:
+  - Слот: `conversation.session.header.utilities`.
+  - Настройки: реестр DSH `settings.register("dsh-cost-meter", Config)` (валюта `currency`, множитель курса `usdRate`, таймзона `displayTimeZone`, опрос OpenRouter `useOpenRouter`, ручные ставки `prices`, сопоставление `modelMap`).
+- API:
+  - HTTP `GET /dsh-cost-meter/state` (параметр `?models=...` для получения тарифов по задействованным моделям).
+- CLI:
+  - Управление через CLI харнесса: `dsh plugin --profile web add @goodandready/dsh-cost-meter`.
+- Документация:
+  - README.md, index.md, docs/testing/public-route.md, docs/deployment/public-release.md.
+
+## Visual Direction
+- Атмосфера: Строгий утилитарный нативный интерфейс DSH, высокая информационная плотность без визуального шума.
+- Утверждённые референсы: Дизайн-система DeepSeek Harness (`--dsw-alias-*`), чипы в шапке сессии (`dsh-key-rotation`, `dsh-context-lens`).
+- Не копировать: Избыточные градиенты, внешние модальные окна, тяжелые тени, кастомные несогласованные шрифты.
+
+## Foundations
+- Цвета и роли:
+  - `--dsw-alias-label-primary`: основной текст, заголовки, суммы.
+  - `--dsw-alias-label-tertiary`: второстепенные пояснения, метки столбцов, чип без тарифа.
+  - `--dsw-alias-border-l2`: разделители секций и обводка панели.
+  - `--dsw-alias-bg-layer-2` / `--dsw-alias-bg-base`: подложка всплывающей панели.
+  - `--dsw-alias-state-success-primary` / `--dsw-alias-state-success-tertiary`: подсветка льготного окна (не-пик).
+  - `--dsw-alias-state-warn-primary` / `--dsw-alias-state-warn-tertiary`: подсветка полного тарифа (пик).
+- Типографика:
+  - Системный стек шрифтов DSH, размер 12px, интерлиньяж 1.5.
+  - Обязательно `fontVariantNumeric: "tabular-nums"` для всех числовых колонок, токенов и таймеров.
+- Сетка и отступы:
+  - Чип: высота 22px, padding: 0 8px, gap: 6px, border-radius: 6px.
+  - Панель: padding: 12px 14px, border-radius: 10px, ширина 320px.
+  - Сетки: `grid` с выравниванием числовых колонок по правому краю (`text-align: right`).
+- Accessibility:
+  - Семантические теги `button` для интерактивных элементов, нативные `title` подсказки при наведении, закрытие панели при клике вне компонента.
+
+## Components And States
+- Чип:
+  - `Loading / Init`: если данные ещё не загружены, чип скрыт (`null`).
+  - `Unknown Tariff`: отображает «тариф ?» в приглушённом цвете `label-tertiary`.
+  - `Flat Tariff`: фон `--dsw-alias-state-warn-tertiary`, текст `--dsw-alias-state-warn-primary`, заголовок «Единый тариф».
+  - `Off-Peak`: зелёная плашка успеха (льготный тариф).
+  - `Peak`: оранжевая плашка предупреждения (полный тариф).
+  - Таймер: время до смены тарифа с пониженной непрозрачностью (`opacity: 0.75`).
+- Панель:
+  - Заголовок с текущей моделью и статусом окна.
+  - Сетка тарифов за 1M токенов (не-пик / пик / единая ставка).
+  - Блок «Из чего сложилась сумма»:
+    - Список всех моделей сессии с токенами и суммарной стоимостью.
+    - Для модели без тарифа отображается статус `не указана стоимость`.
+  - Итог сессии: `Сессия: ≈ <валюта><сумма>`.
+  - Отсутствие мусорных служебных плашек (строка источника OpenRouter исключена).
+
+## User Flows
+1. Пользователь ведёт диалог с ассистентом: чип в шапке инкрементально обновляет потраченную сумму прямо во время стриминга ответа ассистента.
+2. Пользователь нажимает на чип: открывается всплывающая панель с тарифной сеткой и расходами по каждой модели сессии.
+3. Если модель не тарифицирована: в списке моделей выводится статус `не указана стоимость`.
+
+## Do / Don't
+- Do:
+  - Использовать CSS-переменные DSH для согласованности с тёмной и светлой темами.
+  - Всегда разделять расходы по задействованным моделям.
+  - Использовать табличные цифры (`tabular-nums`) для предотвращения дёргания вёрстки при стриме.
+- Don't:
+  - Не выводить техническую служебную информацию о каталоге OpenRouter в интерфейс пользователя.
+  - Не заменять отсутствие тарифа обманчивым нулём или невнятным прочерком — писать прямо `не указана стоимость`.
+  - Не допускать утечек локальных путей и инфраструктурных данных в коде или документации.
+
+## History & Decisions
+- 2026-09-05 (v0.7.3):
+  - Удалена строка источника цен OpenRouter.
+  - Список моделей в блоке «Из чего сложилась сумма» унифицирован и отображается для всех задействованных моделей сессии.
+  - Для нетарифицированных моделей введён явный статус «не указана стоимость».
+  - Пакет переведён на публичный scope `@goodandready/dsh-cost-meter`.

package/docs/testing/public-route.md

@@ -0,0 +1,12 @@
+# Проверка публичного маршрута
+
+1. Выполнить `npm test`.
+2. Проверить `npm pack --dry-run` и отсутствие локальных установочных ссылок,
+   абсолютных infra-путей, IP-адресов и секретов в поставляемых файлах.
+3. Собрать tarball из проверенного Git worktree.
+4. Установить tarball на изолированный тестовый DSH web server (MiniPC).
+5. Для browser half проверить loader id `@goodandready/dsh-cost-meter`, HTTP route
+   состояния `GET /dsh-cost-meter/state` и smoke-сценарий тарификации (список моделей,
+   расчёт стоимости, статус «не указана стоимость»); для host half — bundle identity и host smoke.
+6. Выполнить cleanup тестовой установки и убедиться, что постоянные плагины
+   сохранили работоспособность.

package/lib/client.js

@@ -0,0 +1,471 @@
+// dsh-cost-meter — browser half.
+//
+// One chip in `conversation.session.header.utilities` (kind: list, scope:
+// session). Session-scoped slots hand the component `useProjection`, so token
+// counts come from dsh-token-meter's `tokenUsage` projection and move while a
+// turn streams. The tariff schedule arrives from the host over GET
+// /dsh-cost-meter/state — a base rate card plus UTC discount windows.
+//
+// The client owns only the clock: which window is active now, when it flips,
+// and which variant of the day is the cheap one.
+//
+// Not ESM: the shell loads this file as a lazy CJS factory. No import, no JSX.
+window.__ModuleLoader__.load({
+  id: '@goodandready/dsh-cost-meter',
+  factory: (require) => {
+    var module = { exports: {} }
+    const React = require('react')
+    const h = React.createElement
+
+    const STATE_PATH = '/dsh-cost-meter/state'
+    const DAY = 1440
+
+    // ---------------------------------------------------------------- tariff
+
+    function inWindow(minute, w) {
+      return w.start <= w.end ? minute >= w.start && minute < w.end : minute >= w.start || minute < w.end
+    }
+
+    /** Rates in force at a given UTC minute: the last matching window, else base. */
+    function ratesAt(schedule, minute) {
+      const windows = (schedule && schedule.windows) || []
+      for (const w of windows) if (inWindow(minute, w)) return w.rates
+      return (schedule && schedule.base) || { cacheHit: 0, input: 0, cacheWrite: 0, output: 0 }
+    }
+
+    /** Minutes until the rate card changes, or null when it never does. */
+    function minutesUntilChange(schedule, minute) {
+      const now = ratesAt(schedule, minute)
+      for (let step = 1; step <= DAY; step += 1) {
+        const probe = ratesAt(schedule, (minute + step) % DAY)
+        if (probe.output !== now.output || probe.input !== now.input) return step
+      }
+      return null
+    }
+
+    /**
+     * The day's two extremes, by output rate: what the widget labels
+     * "не-пик" and "пик". Equal extremes mean a flat tariff.
+     */
+    function extremes(schedule) {
+      let low = null
+      let high = null
+      for (let minute = 0; minute < DAY; minute += 1) {
+        const r = ratesAt(schedule, minute)
+        if (!low || r.output < low.output) low = r
+        if (!high || r.output > high.output) high = r
+      }
+      return { low: low || {}, high: high || {}, flat: !low || !high || low.output === high.output }
+    }
+
+    /** Total tokens across every half-hour slot of one model. */
+    function sumSlots(slots) {
+      const total = { uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }
+      for (const key of Object.keys(slots || {})) {
+        const b = slots[key] || {}
+        for (const field of Object.keys(total)) total[field] += Number(b[field]) || 0
+      }
+      return total
+    }
+
+    /**
+     * Cost of one model, each half-hour slot charged at the rate that applied
+     * in that slot. Slot 14 is 07:00–07:30 UTC, so its midpoint (07:15) picks
+     * the window without landing on a boundary.
+     */
+    function spendBySlots(slots, schedule) {
+      let usd = 0
+      for (const key of Object.keys(slots || {})) {
+        const minute = (Number(key) * 30 + 15) % 1440
+        usd += spendUsd(slots[key], ratesAt(schedule, minute))
+      }
+      return usd
+    }
+
+    /** Session spend in USD for one rate card. */
+    function spendUsd(usage, rates) {
+      const u = usage || {}
+      const perMillion =
+        (Number(u.cacheReadTokens) || 0) * (rates.cacheHit || 0) +
+        (Number(u.uncachedInputTokens) || 0) * (rates.input || 0) +
+        (Number(u.cacheWriteTokens) || 0) * (rates.cacheWrite || 0) +
+        (Number(u.outputTokens) || 0) * (rates.output || 0)
+      return perMillion / 1e6
+    }
+
+    // --------------------------------------------------------------- format
+
+    function rate(value) {
+      if (!value) return '—'
+      const text = value < 0.1 ? value.toFixed(3) : value.toFixed(2)
+      return '$' + text.replace(/(\.\d*?)0+$/, '$1').replace(/\.$/, '')
+    }
+
+    function money(value, currency) {
+      return currency + value.toFixed(Math.abs(value) >= 100 ? 0 : 2)
+    }
+
+    function tokens(value) {
+      const n = Number(value) || 0
+      if (n >= 1e6) return (n / 1e6).toFixed(2) + 'M'
+      if (n >= 1e3) return (n / 1e3).toFixed(1) + 'K'
+      return String(n)
+    }
+
+    function clock(minutes) {
+      if (minutes === null) return null
+      return Math.floor(minutes / 60) + ':' + String(minutes % 60).padStart(2, '0')
+    }
+
+    function hhmm(minute) {
+      return String(Math.floor(minute / 60)).padStart(2, '0') + ':' + String(minute % 60).padStart(2, '0')
+    }
+
+    /**
+     * Render a UTC minute-of-day in the display zone. Built from a real Date so
+     * the zone's current offset (and any DST) comes from Intl, not arithmetic.
+     */
+    function hhmmInZone(minute, zone, reference) {
+      const d = new Date(Date.UTC(
+        reference.getUTCFullYear(), reference.getUTCMonth(), reference.getUTCDate(), 0, minute,
+      ))
+      try {
+        return new Intl.DateTimeFormat('ru-RU', {
+          hour: '2-digit', minute: '2-digit', hour12: false, timeZone: zone,
+        }).format(d)
+      } catch {
+        return hhmm(minute)
+      }
+    }
+
+    /** Short zone label for the panel: "МСК" for Moscow, else the city part. */
+    function zoneLabel(zone) {
+      if (!zone) return 'UTC'
+      if (zone === 'Europe/Moscow') return 'МСК'
+      const city = zone.includes('/') ? zone.slice(zone.lastIndexOf('/') + 1) : zone
+      return city.replace(/_/g, ' ')
+    }
+
+    function ago(timestamp) {
+      if (!timestamp) return 'нет данных'
+      const minutes = Math.max(0, Math.round((Date.now() - timestamp) / 60000))
+      if (minutes < 60) return minutes + ' мин назад'
+      const hours = Math.round(minutes / 60)
+      return hours < 48 ? hours + ' ч назад' : Math.round(hours / 24) + ' дн назад'
+    }
+
+    // ---------------------------------------------------------------- styles
+
+    const C = {
+      label: 'var(--dsw-alias-label-primary)',
+      muted: 'var(--dsw-alias-label-tertiary)',
+      line: 'var(--dsw-alias-border-l2)',
+      panelBg: 'var(--dsw-alias-bg-layer-2, var(--dsw-alias-bg-base))',
+      okFg: 'var(--dsw-alias-state-success-primary)',
+      okBg: 'var(--dsw-alias-state-success-tertiary)',
+      warnFg: 'var(--dsw-alias-state-warn-primary)',
+      warnBg: 'var(--dsw-alias-state-warn-tertiary)',
+    }
+
+    const S = {
+      chip: {
+        display: 'inline-flex', alignItems: 'center', gap: 6, height: 22, padding: '0 8px',
+        borderRadius: 6, border: 'none', cursor: 'pointer', font: 'inherit', fontSize: 12,
+        fontVariantNumeric: 'tabular-nums', lineHeight: '22px',
+      },
+      panel: {
+        position: 'absolute', top: 28, right: 0, zIndex: 40, width: 320, padding: '12px 14px',
+        borderRadius: 10, border: '1px solid ' + C.line, background: C.panelBg,
+        boxShadow: '0 10px 30px rgba(0,0,0,.28)', fontSize: 12, lineHeight: 1.5,
+        color: C.label, textAlign: 'left', fontVariantNumeric: 'tabular-nums',
+      },
+      title: { fontWeight: 600, paddingBottom: 4 },
+      note: { color: C.muted },
+      hr: { height: 1, background: C.line, margin: '10px -14px' },
+      grid: { display: 'grid', gridTemplateColumns: '1fr 60px 60px', columnGap: 6, alignItems: 'center' },
+      gridFlat: { display: 'grid', gridTemplateColumns: '1fr 72px', columnGap: 6, alignItems: 'center' },
+      grid3: { display: 'grid', gridTemplateColumns: '1fr 58px 72px', columnGap: 6, alignItems: 'center' },
+      th: { color: C.muted, paddingBottom: 4 },
+      thNum: { color: C.muted, paddingBottom: 4, textAlign: 'right' },
+      td: { padding: '3px 0' },
+      cellIdle: { textAlign: 'right', padding: '3px 6px', borderRadius: 4, color: C.muted },
+      num: { textAlign: 'right', color: C.muted, padding: '3px 0' },
+      cost: { textAlign: 'right', padding: '3px 0' },
+      section: { color: C.muted, paddingBottom: 4 },
+      total: { display: 'flex', justifyContent: 'space-between', fontWeight: 600 },
+    }
+
+    // ------------------------------------------------------------ component
+
+    function CostMeter(props) {
+      const useProjection = props.useProjection
+      const usage = useProjection ? useProjection('tokenUsage') : undefined
+      const byModel = useProjection ? useProjection('costByModel') : undefined
+      const [state, setState] = React.useState(null)
+      const [open, setOpen] = React.useState(false)
+      const [now, setNow] = React.useState(() => new Date())
+      const box = React.useRef(null)
+
+      // Every model this session actually billed, so each part is priced on its
+      // own tariff instead of the current model's. Usage arrives split into
+      // half-hour slots of the UTC day — spend is charged at the rate that was
+      // in force then, so a tariff switch never reprices what is already spent.
+      const used = (byModel && Array.isArray(byModel.models) ? byModel.models : [])
+        .map((m) => ({ ...m, usage: sumSlots(m && m.slots) }))
+        .filter((m) => m.usage.uncachedInputTokens || m.usage.outputTokens ||
+          m.usage.cacheReadTokens || m.usage.cacheWriteTokens)
+      const usedKeys = used.map((m) => m.provider + '/' + m.model).sort().join(',')
+
+      const load = React.useCallback((keys) => {
+        const query = keys ? '?models=' + encodeURIComponent(keys) : ''
+        fetch(STATE_PATH + query, { headers: { accept: 'application/json' } })
+          .then((r) => (r.ok ? r.json() : null))
+          .then((data) => { if (data) setState(data) })
+          .catch(() => {})
+      }, [])
+
+      // Refetch when the set of billed models changes — a new model needs its
+      // own tariff before its tokens can be priced.
+      React.useEffect(() => { load(usedKeys) }, [load, usedKeys])
+      React.useEffect(() => { if (open) load(usedKeys) }, [open, load, usedKeys])
+      React.useEffect(() => {
+        const id = setInterval(() => setNow(new Date()), 15000)
+        return () => clearInterval(id)
+      }, [])
+      React.useEffect(() => {
+        if (!open) return undefined
+        const onDown = (e) => { if (box.current && !box.current.contains(e.target)) setOpen(false) }
+        document.addEventListener('mousedown', onDown)
+        return () => document.removeEventListener('mousedown', onDown)
+      }, [open])
+
+      if (!state) return null
+
+      const currency = state.currency || '$'
+      const fx = Number(state.usdRate) || 1
+      const schedule = state.schedule
+      const hasUsage = usage !== undefined && usage !== null
+      const minute = now.getUTCHours() * 60 + now.getUTCMinutes()
+
+      // No rate card for this route: say so instead of showing a fake zero.
+      if (!schedule) {
+        return h('div', { ref: box, style: { position: 'relative' } }, [
+          h('button', {
+            key: 'chip', type: 'button',
+            style: Object.assign({}, S.chip, { background: 'transparent', color: C.muted }),
+            onClick: () => setOpen((v) => !v), title: 'Тариф неизвестен',
+          }, 'тариф ?'),
+          open ? h('div', { key: 'panel', style: S.panel }, [
+            h('div', { key: 't', style: S.title },
+              state.route ? state.route.provider + ' / ' + state.route.model : 'маршрут неизвестен'),
+            h('div', { key: 'n', style: S.note },
+              state.catalogError
+                ? 'Каталог OpenRouter недоступен: ' + state.catalogError
+                : 'Модель не найдена в каталоге OpenRouter. Задайте ставки вручную в настройках (prices) или сопоставьте модель через modelMap.'),
+          ]) : null,
+        ])
+      }
+
+      const active = ratesAt(schedule, minute)
+      const { low, high, flat } = extremes(schedule)
+      const cheapNow = !flat && active.output === low.output
+      const left = clock(minutesUntilChange(schedule, minute))
+
+      // Per-model spend: each model on its own tariff, at that tariff's rate
+      // for the current moment. Falls back to the session-wide totals when the
+      // per-model projection is unavailable (older harness, headless).
+      const schedules = state.schedules || {}
+      const perModel = used.map((m) => {
+        const key = m.provider + '/' + m.model
+        const own = schedules[key]
+        const ownSchedule = own && own.schedule
+        return {
+          key,
+          model: m.model,
+          usage: m.usage,
+          known: Boolean(ownSchedule),
+          cost: ownSchedule ? spendBySlots(m.slots, ownSchedule) * fx : 0,
+        }
+      })
+      const multiModel = perModel.length > 1
+      const total = perModel.length
+        ? perModel.reduce((sum, m) => sum + m.cost, 0)
+        : spendUsd(usage, active) * fx
+      const unpriced = perModel.filter((m) => !m.known)
+
+      const fg = cheapNow ? C.okFg : C.warnFg
+      const bg = cheapNow ? C.okBg : C.warnBg
+      const activeCell = { textAlign: 'right', padding: '3px 6px', borderRadius: 4, background: bg, color: fg, fontWeight: 600 }
+
+      // Two tiers: cheap and full side by side, the active one filled.
+      // One tier: a single plain column, no highlight to explain.
+      const rateRow = (label, key) => flat
+        ? [
+            h('div', { key: label + '-l', style: S.td }, label),
+            h('div', { key: label + '-v', style: S.cost }, rate(active[key])),
+          ]
+        : [
+            h('div', { key: label + '-l', style: S.td }, label),
+            h('div', { key: label + '-lo', style: cheapNow ? activeCell : S.cellIdle }, rate(low[key])),
+            h('div', { key: label + '-hi', style: cheapNow ? S.cellIdle : activeCell }, rate(high[key])),
+          ]
+
+      // Breakdown row for the single-model case: tokens in the bucket and what
+      // they actually accrued, slot by slot, at the rate of each slot.
+      const soleSlots = perModel.length === 1 ? used[0].slots : null
+      const spentRow = (label, bucketField, rateField) => {
+        const n = Number(usage && usage[bucketField]) || 0
+        let usd = 0
+        if (soleSlots) {
+          for (const key of Object.keys(soleSlots)) {
+            const rates = ratesAt(schedule, (Number(key) * 30 + 15) % 1440)
+            usd += ((Number(soleSlots[key][bucketField]) || 0) / 1e6) * (rates[rateField] || 0)
+          }
+        } else {
+          usd = (n / 1e6) * (active[rateField] || 0)
+        }
+        return [
+          h('div', { key: label + '-l', style: S.td }, label),
+          h('div', { key: label + '-n', style: S.num }, tokens(n)),
+          h('div', { key: label + '-v', style: S.cost }, money(usd * fx, currency)),
+        ]
+      }
+
+      const showCacheWrite = Number(usage && usage.cacheWriteTokens) > 0
+      const zone = state.displayTimeZone || 'Europe/Moscow'
+      const zl = zoneLabel(zone)
+      const windowText = (schedule.windows || [])
+        .map((w) => hhmmInZone(w.start, zone, now) + '–' + hhmmInZone(w.end, zone, now))
+        .join(', ')
+      const nowLocal = hhmmInZone(minute, zone, now)
+
+      return h('div', { ref: box, style: { position: 'relative' } }, [
+        h('button', {
+          key: 'chip', type: 'button',
+          style: Object.assign({}, S.chip, { background: bg, color: fg }),
+          onClick: () => setOpen((v) => !v),
+          title: flat ? 'Единый тариф' : cheapNow ? 'Льготный тариф' : 'Полный тариф',
+        }, [
+          h('span', { key: 'sum' }, hasUsage ? '≈ ' + money(total, currency) : '—'),
+          left ? h('span', { key: 'left', style: { opacity: 0.75 } }, left) : null,
+        ]),
+
+        open ? h('div', { key: 'panel', style: S.panel }, [
+          h('div', { key: 'title', style: S.title },
+            (state.route ? state.route.model : 'модель') +
+            (flat ? '' : ' — сейчас ' + (cheapNow ? 'не-пик' : 'пик'))),
+
+          h('div', { key: 'note', style: S.note },
+            flat
+              ? 'Единая ставка, от времени суток не зависит'
+              : (cheapNow ? 'Действует льготная ставка' : 'Действует полная ставка') +
+                (left ? ' · смена через ' + left : '')),
+
+          flat
+            ? null
+            : h('div', { key: 'clock', style: S.note },
+                'Пик: ' + windowText + ' ' + zl + ' · сейчас ' + nowLocal + ' ' + zl),
+
+          h('div', { key: 'hr1', style: S.hr }),
+
+          h('div', { key: 'rates', style: flat ? S.gridFlat : S.grid }, [
+            h('div', { key: 'h0', style: S.th }, '1M токенов, $'),
+            flat ? null : h('div', { key: 'h1', style: S.thNum }, 'не-пик'),
+            h('div', { key: 'h2', style: S.thNum }, flat ? 'ставка' : 'пик'),
+            rateRow('Вход (кэш-хит)', 'cacheHit'),
+            rateRow('Вход (мимо кэша)', 'input'),
+            showCacheWrite ? rateRow('Вход (запись в кэш)', 'cacheWrite') : null,
+            rateRow('Выход', 'output'),
+          ]),
+
+          h('div', { key: 'hr2', style: S.hr }),
+
+          multiModel
+            ? null
+            : [
+                h('div', { key: 'btitle', style: S.section }, 'Токены сессии'),
+                h('div', { key: 'breakdown', style: S.grid3 }, [
+                  h('div', { key: 'b0', style: S.th }, 'токенов'),
+                  h('div', { key: 'b1', style: S.thNum }, ''),
+                  h('div', { key: 'b2', style: S.thNum }, currency),
+                  spentRow('Вход (кэш-хит)', 'cacheReadTokens', 'cacheHit'),
+                  spentRow('Вход (мимо кэша)', 'uncachedInputTokens', 'input'),
+                  showCacheWrite ? spentRow('Вход (запись в кэш)', 'cacheWriteTokens', 'cacheWrite') : null,
+                  spentRow('Выход', 'outputTokens', 'output'),
+                ]),
+                h('div', { key: 'hr-models', style: S.hr }),
+              ],
+
+          h('div', { key: 'mtitle', style: S.section }, 'Расход по моделям'),
+          h(
+            'div',
+            { key: 'models-list', style: { display: 'flex', flexDirection: 'column', gap: 4 } },
+            (perModel.length
+              ? perModel
+              : (state.route ? [{ key: state.route.provider + '/' + state.route.model, model: state.route.model, known: Boolean(schedule), cost: 0 }] : [])
+            ).map((m) =>
+              h(
+                'div',
+                {
+                  key: m.key,
+                  style: { display: 'flex', justifyContent: 'space-between', alignItems: 'center', gap: 8, padding: '2px 0' },
+                },
+                [
+                  h(
+                    'span',
+                    {
+                      key: 'name',
+                      title: m.key,
+                      style: {
+                        overflow: 'hidden',
+                        textOverflow: 'ellipsis',
+                        whiteSpace: 'nowrap',
+                        maxWidth: m.known ? 200 : 130,
+                      },
+                    },
+                    m.model,
+                  ),
+                  h(
+                    'span',
+                    {
+                      key: 'val',
+                      style: {
+                        textAlign: 'right',
+                        fontVariantNumeric: 'tabular-nums',
+                        whiteSpace: 'nowrap',
+                        color: m.known ? C.label : C.muted,
+                      },
+                    },
+                    m.known ? (hasUsage ? money(m.cost, currency) : '—') : 'не указана стоимость',
+                  ),
+                ],
+              ),
+            ),
+          ),
+
+          h('div', { key: 'hr3', style: S.hr }),
+
+          h('div', { key: 'total', style: S.total }, [
+            h('span', { key: 'l' }, 'Сессия:'),
+            h('span', { key: 'v' }, hasUsage ? '≈ ' + money(total, currency) : 'нет данных'),
+          ]),
+
+          hasUsage ? null : h('div', { key: 'nodata', style: Object.assign({}, S.note, { paddingTop: 6 }) },
+            'Провайдер ещё не сообщил usage для этой сессии.'),
+        ]) : null,
+      ])
+    }
+
+    function apply(ctx) {
+      ctx.slots.inject('conversation.session.header.utilities', () =>
+        ctx.slots.register(
+          { name: 'conversation.session.header.utilities', id: 'dsh-cost-meter', order: 10 },
+          CostMeter,
+        ),
+      )
+    }
+
+    module.exports = { apply, inject: ['slots'] }
+    return module.exports
+  },
+})

package/lib/index.js

@@ -0,0 +1,530 @@
+// dsh-cost-meter — host half.
+//
+// The harness prices nothing on purpose: pi-ai carries a `cost` field but
+// zeroes it and no consumer reports spend. So this half owns the rate card and
+// serves it to the browser over GET /dsh-cost-meter/state.
+//
+// Rates come from OpenRouter's public catalog (https://openrouter.ai/api/v1/models,
+// no auth). Besides the four token buckets it also publishes `pricing.overrides`
+// — time-of-day discount windows keyed by UTC HHMM — which is exactly the
+// peak/off-peak schedule DeepSeek runs. So the whole tariff, windows included,
+// is derived rather than typed in; `prices` in config stays as a manual
+// override for routes the catalog does not know (self-hosted, subscriptions).
+//
+// No agent hooks: the widget only reads, so it cannot corrupt a session.
+
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import z from '@deepseek-ai/schemastery'
+import { z as zod } from 'zod'
+
+export const name = 'dsh-cost-meter'
+export const inject = ['webServer']
+
+const NS = 'dsh-cost-meter'
+const STATE_PATH = '/dsh-cost-meter/state'
+const CATALOG_URL = 'https://openrouter.ai/api/v1/models'
+const CACHE_FILE = join(process.env.DSH_HOME || join(homedir(), '.dsh'), 'storages', 'dsh-cost-meter-catalog.json')
+
+/** One route's rates, in USD per 1M tokens. */
+const PriceRow = z.object({
+  cacheHit: z.number().description('Input tokens served from the provider cache.').default(0),
+  input: z.number().description('Input tokens that missed the cache.').default(0),
+  cacheWrite: z.number().description('Input tokens written into the cache.').default(0),
+  output: z.number().description('Output tokens (reasoning included).').default(0),
+})
+
+/**
+ * DeepSeek's own tariff, from https://api-docs.deepseek.com/quick_start/pricing.
+ * Their API publishes no prices (/models lists ids, there is no pricing route),
+ * and OpenRouter's `deepseek/*` entries quote different numbers, so this table
+ * is the authoritative source for the official route. Values are PEAK, USD per
+ * 1M tokens; off-peak is exactly half. Peak: 01:00-04:00 and 06:00-10:00 UTC.
+ */
+const DEEPSEEK_PEAK_RATES = {
+  'deepseek-v4-flash': { cacheHit: 0.014, input: 0.44, cacheWrite: 0.44, output: 1.32 },
+  'deepseek-v4-pro': { cacheHit: 0.044, input: 1.32, cacheWrite: 1.32, output: 3.96 },
+}
+const DEEPSEEK_PEAK_WINDOWS = [{ start: 60, end: 240 }, { start: 360, end: 600 }]
+
+// ponytail: a DeepSeek model reached THROUGH OpenRouter is still priced from
+// this table, though the bill comes from OpenRouter. Fix by classifying the
+// route (provider id / baseURL) before the model, and for a `:floor` slug take
+// the minimum over /models/{id}/endpoints rather than the base listing.
+
+export const Config = z.object({
+  currency: z.string().description('Currency symbol shown in the widget.').default('$'),
+  usdRate: z.number().description('Units of `currency` per USD. 1 keeps everything in USD.').default(1),
+  displayTimeZone: z
+    .string()
+    .description('IANA zone the widget shows tariff hours in.')
+    .default('Europe/Moscow'),
+  deepseekPeakPrices: z
+    .dict(PriceRow)
+    .description('Override the built-in DeepSeek peak rates, by model id.')
+    .default({}),
+  useOpenRouter: z
+    .boolean()
+    .description('Pull rates and discount windows from the public OpenRouter catalog.')
+    .default(true),
+  refreshHours: z.number().description('How often to refetch the catalog.').default(24),
+  modelMap: z
+    .dict(z.string())
+    .description('Route override: "provider/model" -> OpenRouter model id.')
+    .default({}),
+  prices: z
+    .dict(PriceRow)
+    .description('Manual rates by "provider/model" (or "*"). Win over the catalog.')
+    .default({}),
+  manualPeakWindowsUtc: z
+    .array(z.string())
+    .description('Peak windows HH:MM-HH:MM UTC, used only with manual prices.')
+    .default([]),
+  manualOffPeakMultiplier: z
+    .number()
+    .description('Multiplier outside the manual peak windows.')
+    .default(1),
+})
+
+/** OpenRouter prices are USD per token; the widget speaks per 1M tokens. */
+function perMillion(value) {
+  const n = Number(value)
+  return Number.isFinite(n) ? n * 1e6 : 0
+}
+
+/** Pull the four buckets out of one OpenRouter pricing object. */
+function bucketsOf(pricing) {
+  return {
+    cacheHit: perMillion(pricing.input_cache_read),
+    input: perMillion(pricing.prompt),
+    cacheWrite: perMillion(pricing.input_cache_write),
+    output: perMillion(pricing.completion),
+  }
+}
+
+/** OpenRouter encodes window edges as UTC HHMM integers (1000 = 10:00). */
+export function hhmmToMinutes(value) {
+  const n = Number(value)
+  if (!Number.isFinite(n) || n < 0 || n > 2400) return undefined
+  return Math.floor(n / 100) * 60 + (n % 100)
+}
+
+/** "HH:MM-HH:MM" -> {start,end} in minutes; undefined when malformed. */
+export function parseWindow(spec) {
+  const m = /^(\d{1,2}):(\d{2})-(\d{1,2}):(\d{2})$/.exec(String(spec).trim())
+  if (!m) return undefined
+  return { start: Number(m[1]) * 60 + Number(m[2]), end: Number(m[3]) * 60 + Number(m[4]) }
+}
+
+/**
+ * Normalize one catalog entry into the schedule the browser consumes:
+ * a base rate card plus the discount windows that shadow it.
+ */
+function scheduleOf(entry) {
+  const pricing = entry.pricing || {}
+  const base = bucketsOf(pricing)
+  const windows = []
+  for (const override of pricing.overrides || []) {
+    const start = hhmmToMinutes(override.utc_start)
+    const end = hhmmToMinutes(override.utc_end)
+    if (start === undefined || end === undefined) continue
+    // An override omits buckets it does not change; fall back to the base.
+    const rates = bucketsOf(override)
+    windows.push({
+      start,
+      end,
+      rates: {
+        cacheHit: rates.cacheHit || base.cacheHit,
+        input: rates.input || base.input,
+        cacheWrite: rates.cacheWrite || base.cacheWrite,
+        output: rates.output || base.output,
+      },
+    })
+  }
+  return { base, windows }
+}
+
+/**
+ * Map a harness route onto an OpenRouter id. Exact id first, then the vendor
+ * suffix (`deepseek-official/deepseek-v4-flash` -> `deepseek/deepseek-v4-flash`),
+ * which is what the shared model names make possible.
+ */
+export function matchModel(index, route, modelMap) {
+  if (!route) return undefined
+  const key = route.provider + '/' + route.model
+  const mapped = modelMap && modelMap[key]
+  if (mapped && index.byId[mapped]) return mapped
+  if (index.byId[key]) return key
+  if (index.byId[route.model]) return route.model
+  // Harness routes name models in their own casing (`MiniMax-M3`), the catalog
+  // is lower-case (`minimax/minimax-m3`), so matching is case-insensitive.
+  const lower = String(route.model).toLowerCase()
+  if (index.byLowerId[lower]) return index.byLowerId[lower]
+  if (index.byLowerId[key.toLowerCase()]) return index.byLowerId[key.toLowerCase()]
+  const bySuffix = index.bySuffix[lower]
+  return bySuffix && bySuffix.length ? bySuffix[0] : undefined
+}
+
+/** Build lookup tables once per fetch; the raw catalog is ~700 KB. */
+export function indexCatalog(models) {
+  const byId = {}
+  const byLowerId = {}
+  const bySuffix = {}
+  for (const entry of models) {
+    if (!entry || typeof entry.id !== 'string' || !entry.pricing) continue
+    // Variants like ":batch" or ":free" are different products; skip them so a
+    // suffix match cannot silently price against a cheaper batch tier.
+    if (entry.id.includes(':')) continue
+    byId[entry.id] = scheduleOf(entry)
+    byLowerId[entry.id.toLowerCase()] = entry.id
+    const suffix = entry.id.includes('/') ? entry.id.slice(entry.id.indexOf('/') + 1) : entry.id
+    ;(bySuffix[suffix.toLowerCase()] = bySuffix[suffix.toLowerCase()] || []).push(entry.id)
+  }
+  return { byId, byLowerId, bySuffix }
+}
+
+// ---------------------------------------------------------------------------
+// Per-model usage projection
+//
+// `tokenUsage` from dsh-token-meter totals the whole session, which prices
+// wrongly the moment the model changes mid-session. The log has what is
+// needed: `request/header` carries `header.config = {provider, model}`, and
+// usage arrives afterwards for that same step. So this unit keeps the last
+// header's route and files every usage sample under it.
+//
+// The replace-if-same-step guard mirrors token-meter: a streamed usage chunk
+// and the finalized assistant message report the same numbers for one step.
+// ---------------------------------------------------------------------------
+
+const ZERO = { uncachedInputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0 }
+
+// Projection schemas are validated with ZOD, not schemastery: the registry
+// calls `schema.parse(view)` at the boundary, and a schemastery schema has no
+// `.parse`, which fails every history read with
+// "registration.def.schema.parse is not a function".
+const bucketSchema = zod.object({
+  uncachedInputTokens: zod.number().nonnegative(),
+  outputTokens: zod.number().nonnegative(),
+  cacheReadTokens: zod.number().nonnegative(),
+  cacheWriteTokens: zod.number().nonnegative(),
+}).strict()
+
+/** Pull the four buckets out of one provider usage record. */
+function bucketsFromUsage(usage) {
+  return {
+    uncachedInputTokens: Number(usage.inputTokens) || 0,
+    outputTokens: Number(usage.outputTokens) || 0,
+    cacheReadTokens: Number(usage.cacheReadTokens) || 0,
+    cacheWriteTokens: Number(usage.cacheWriteTokens) || 0,
+  }
+}
+
+function addBuckets(base, remove, add) {
+  const out = {}
+  for (const k of Object.keys(ZERO)) {
+    out[k] = (base[k] || 0) - ((remove && remove[k]) || 0) + (add[k] || 0)
+  }
+  return out
+}
+
+function sameBuckets(a, b) {
+  return a && b && Object.keys(ZERO).every((k) => (a[k] || 0) === (b[k] || 0))
+}
+
+/** The usage a streamed chunk or a finalized assistant message reports. */
+function usageOf(event) {
+  if (event.type === 'assistant/chunk' && event.data.chunk && event.data.chunk.type === 'usage') {
+    return { turn: event.data.turn, step: event.data.step, usage: event.data.chunk.usage }
+  }
+  if (event.type === 'assistant/message' && event.data.usage !== undefined) {
+    return { turn: event.data.turn, step: event.data.step, usage: event.data.usage }
+  }
+  return undefined
+}
+
+/**
+ * Half-hour slot of the UTC day an event falls into (0..47). Tariff windows are
+ * expressed in UTC clock time, and every real schedule so far lands on a whole
+ * or half hour, so 48 slots reproduce the rate exactly while keeping the state
+ * small enough to ship on every projection frame.
+ */
+export function slotOf(timeMs) {
+  const d = new Date(timeMs)
+  return Math.floor((d.getUTCHours() * 60 + d.getUTCMinutes()) / 30)
+}
+
+const usageByModelProjection = {
+  key: 'costByModel',
+  schema: zod.object({
+    models: zod.array(zod.object({
+      provider: zod.string(),
+      model: zod.string(),
+      // Usage split by the half-hour of the UTC day it was spent in. Spend is
+      // priced at the rate in force THEN; a later tariff switch must not
+      // reprice tokens that are already paid for.
+      slots: zod.record(zod.string(), bucketSchema),
+    })),
+  }).strict(),
+  init: () => ({ route: null, byKey: {}, last: null }),
+  apply: (state, event) => {
+    if (event.type === 'request/header') {
+      const config = event.data && event.data.header && event.data.header.config
+      const provider = config && typeof config.provider === 'string' ? config.provider : undefined
+      const model = config && typeof config.model === 'string' ? config.model : undefined
+      if (provider === undefined || model === undefined) return state
+      if (state.route && state.route.provider === provider && state.route.model === model) return state
+      return { ...state, route: { provider, model } }
+    }
+    const sample = usageOf(event)
+    if (sample === undefined) return state
+    const route = state.route || { provider: '', model: 'unknown' }
+    const key = route.provider + '/' + route.model
+    const slot = String(slotOf(event.time))
+    const buckets = bucketsFromUsage(sample.usage)
+    // A streamed usage chunk and the finalized assistant message report the
+    // same step twice; the second one replaces the first instead of adding.
+    const previous =
+      state.last !== null &&
+      state.last.turn === sample.turn &&
+      state.last.step === sample.step &&
+      state.last.key === key &&
+      state.last.slot === slot
+        ? state.last.buckets
+        : undefined
+    if (previous !== undefined && sameBuckets(previous, buckets)) return state
+    const slots = state.byKey[key] || {}
+    return {
+      route: state.route,
+      byKey: {
+        ...state.byKey,
+        [key]: { ...slots, [slot]: addBuckets(slots[slot] || ZERO, previous, buckets) },
+      },
+      last: { turn: sample.turn, step: sample.step, key, slot, buckets },
+    }
+  },
+  view: (state) => ({
+    models: Object.keys(state.byKey).map((key) => {
+      const slash = key.indexOf('/')
+      return {
+        provider: key.slice(0, slash),
+        model: key.slice(slash + 1),
+        slots: state.byKey[key],
+      }
+    }),
+  }),
+  stateVersion: 2,
+}
+
+/** The agent's default route, read off settings descriptors when available. */
+function defaultRoute(ctx) {
+  const settings = ctx.get('settings')
+  if (settings === undefined) return undefined
+  try {
+    const found = settings
+      .describe({ redactSecrets: true })
+      .find((descriptor) => descriptor.ns === 'agent-default-model')
+    const value = found && found.value
+    if (!value || typeof value.provider !== 'string' || typeof value.model !== 'string') return undefined
+    return { provider: value.provider, model: value.model }
+  } catch {
+    return undefined
+  }
+}
+
+/**
+ * Resolve one route's tariff: manual config wins, then DeepSeek's own table,
+ * then the OpenRouter catalog. Returns `schedule: null` when nothing knows it,
+ * so the widget can say so instead of pricing at zero.
+ */
+export function resolveTariff(cfg, index, route) {
+  if (!route) return { schedule: null, source: 'none', matchedId: null }
+  const key = route.provider + '/' + route.model
+  const prices = cfg.prices || {}
+  const manual = prices[key] || prices[route.model] || prices['*']
+
+  if (manual) {
+    const base = {
+      cacheHit: Number(manual.cacheHit) || 0,
+      input: Number(manual.input) || 0,
+      cacheWrite: Number(manual.cacheWrite) || 0,
+      output: Number(manual.output) || 0,
+    }
+    const factor = Number(cfg.manualOffPeakMultiplier) || 1
+    const windows = []
+    for (const spec of cfg.manualPeakWindowsUtc || []) {
+      const parsed = parseWindow(spec)
+      if (parsed) windows.push({ start: parsed.start, end: parsed.end, rates: base })
+    }
+    const schedule = windows.length
+      ? {
+          base: {
+            cacheHit: base.cacheHit * factor,
+            input: base.input * factor,
+            cacheWrite: base.cacheWrite * factor,
+            output: base.output * factor,
+          },
+          windows,
+        }
+      : { base, windows: [] }
+    return { schedule, source: 'manual', matchedId: key }
+  }
+
+  // Keyed by MODEL, not provider: a DeepSeek model is billed at DeepSeek's
+  // published rate whoever routes it (deepseek-official, opencode-go, ollama).
+  // Date/variant suffixes (`deepseek-v4-flash:0731`) name the same product.
+  const base = String(route.model).toLowerCase().split(':')[0]
+  const peak = (cfg.deepseekPeakPrices || {})[base] || DEEPSEEK_PEAK_RATES[base]
+  if (peak) {
+    const full = {
+      cacheHit: Number(peak.cacheHit) || 0,
+      input: Number(peak.input) || 0,
+      cacheWrite: Number(peak.cacheWrite) || 0,
+      output: Number(peak.output) || 0,
+    }
+    return {
+      schedule: {
+        base: {
+          cacheHit: full.cacheHit / 2,
+          input: full.input / 2,
+          cacheWrite: full.cacheWrite / 2,
+          output: full.output / 2,
+        },
+        windows: DEEPSEEK_PEAK_WINDOWS.map((w) => ({ start: w.start, end: w.end, rates: full })),
+      },
+      source: 'deepseek',
+      matchedId: base,
+    }
+  }
+
+  if (cfg.useOpenRouter !== false) {
+    const matchedId = matchModel(index, route, cfg.modelMap)
+    if (matchedId) return { schedule: index.byId[matchedId], source: 'openrouter', matchedId }
+  }
+  return { schedule: null, source: 'none', matchedId: null }
+}
+
+/** "provider/model" -> {provider, model}; the model half may contain slashes. */
+function splitRoute(key) {
+  const slash = String(key).indexOf('/')
+  if (slash < 0) return undefined
+  return { provider: key.slice(0, slash), model: key.slice(slash + 1) }
+}
+
+export function apply(ctx, config) {
+  let current = config
+  let catalog = { index: { byId: {}, bySuffix: {} }, fetchedAt: 0, error: null }
+
+  // Disk cache survives restarts, so a boot without network still prices.
+  try {
+    const cached = JSON.parse(readFileSync(CACHE_FILE, 'utf8'))
+    if (cached && Array.isArray(cached.models)) {
+      catalog = { index: indexCatalog(cached.models), fetchedAt: cached.fetchedAt || 0, error: null }
+    }
+  } catch {
+    // absent or unreadable cache is normal on first run
+  }
+
+  async function refresh(signal) {
+    const cfg = current ?? config
+    if (cfg.useOpenRouter === false) return
+    const ageMs = Date.now() - catalog.fetchedAt
+    if (catalog.fetchedAt && ageMs < (Number(cfg.refreshHours) || 24) * 3600e3) return
+    try {
+      const response = await fetch(CATALOG_URL, { signal, headers: { accept: 'application/json' } })
+      if (!response.ok) throw new Error('HTTP ' + response.status)
+      const body = await response.json()
+      const models = Array.isArray(body && body.data) ? body.data : []
+      if (models.length === 0) throw new Error('empty catalog')
+      // Keep only what pricing needs — the raw payload is mostly prose.
+      const slim = models.map((m) => ({ id: m.id, pricing: m.pricing }))
+      catalog = { index: indexCatalog(slim), fetchedAt: Date.now(), error: null }
+      try {
+        mkdirSync(dirname(CACHE_FILE), { recursive: true })
+        writeFileSync(CACHE_FILE, JSON.stringify({ fetchedAt: catalog.fetchedAt, models: slim }))
+      } catch {
+        // a read-only storages dir only costs us the restart-time cache
+      }
+    } catch (error) {
+      catalog = { ...catalog, error: String((error && error.message) || error) }
+    }
+  }
+
+  // Live config from the GUI, with the composition entry as the base layer.
+  ctx.inject(['settings'], (sctx) => {
+    const scope = sctx.settings.register(NS, Config, { base: config })
+    current = scope.get() ?? config
+    const stop = scope.watch(() => {
+      current = scope.get() ?? config
+      void refresh()
+    })
+    sctx.effect(() => () => {
+      stop()
+      current = config
+    })
+  })
+
+  // Optional capability: headless assemblies without the registry keep working,
+  // the widget just falls back to the session-wide tokenUsage projection.
+  ctx.inject(['sessionProjections'], (pctx) => {
+    pctx.sessionProjections.register(usageByModelProjection)
+  })
+
+  ctx.effect(() => {
+    const controller = new AbortController()
+    void refresh(controller.signal)
+    const timer = setInterval(() => void refresh(controller.signal), 3600e3)
+    return () => {
+      clearInterval(timer)
+      controller.abort()
+    }
+  }, 'dsh-cost-meter: catalog refresh')
+
+  ctx.effect(
+    () =>
+      ctx.webServer.register({
+        kind: 'exact',
+        path: STATE_PATH,
+        handler: (req, res) => {
+          if (req.method !== 'GET') {
+            res.writeHead(405, { 'Content-Type': 'application/json' })
+            res.end(JSON.stringify({ error: 'method not allowed' }))
+            return
+          }
+          const cfg = current ?? config
+          const route = defaultRoute(ctx) ?? null
+          const own = resolveTariff(cfg, catalog.index, route)
+
+          // The client asks for every model the session actually used, so a
+          // session that switched models can price each part on its own tariff.
+          const schedules = {}
+          const asked = new URL(req.url, 'http://localhost').searchParams.get('models')
+          for (const key of (asked ? asked.split(',') : []).slice(0, 24)) {
+            const parsed = splitRoute(key.trim())
+            if (!parsed) continue
+            const resolved = resolveTariff(cfg, catalog.index, parsed)
+            schedules[key.trim()] = {
+              schedule: resolved.schedule,
+              source: resolved.source,
+              matchedId: resolved.matchedId,
+            }
+          }
+
+          res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'no-store' })
+          res.end(JSON.stringify({
+            currency: cfg.currency,
+            usdRate: cfg.usdRate,
+            displayTimeZone: cfg.displayTimeZone || 'Europe/Moscow',
+            route,
+            source: own.source,
+            matchedId: own.matchedId,
+            schedules,
+            fetchedAt: catalog.fetchedAt || null,
+            catalogError: catalog.error,
+            schedule: own.schedule,
+          }))
+        },
+      }),
+    'dsh-cost-meter: state route',
+  )
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@goodandready/dsh-cost-meter",
+  "version": "0.7.3",
+  "description": "DeepSeek Harness plugin: a session cost chip in the conversation header - live token usage by bucket, peak/off-peak tariff, and a countdown to the next tariff switch.",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./cordis.patch.yml": "./cordis.patch.yml",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib",
+    "cordis.patch.yml",
+    "README.md",
+    "docs",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": []
+    }
+  },
+  "keywords": [
+    "deepseek-harness",
+    "dsh",
+    "dsh-plugin",
+    "cost",
+    "tokens",
+    "pricing"
+  ],
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "test": "node --test"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/schemastery": "^3.18.1"
+  },
+  "dependencies": {
+    "zod": "^3.25.76"
+  }
+}