clauderipple 0.8.9 → 0.9.0

package/dist/mod/hooks/ui/theme.ts

@@ -0,0 +1,217 @@
+// Colours and SVG plumbing shared by every drawing of the mod. Pure: no engine calls.
+//
+// The look is calm at rest: neutral ink on the host's own background, the ClaudeRipple accent
+// (#6a56d6, packages/ui/style.css) only where something wants attention, and green/amber/red kept
+// for results. SVG chips do not know the host's background, so they are drawn in translucent ink
+// (a few percent of the text colour) and sit on the Code tab's warm or cool greys alike.
+
+export type Appearance = 'auto' | 'dark' | 'light'
+
+export type Palette = {
+  /** Body text. */
+  ink: string
+  /** Secondary text. */
+  muted: string
+  /** Hairlines, unlit glyph parts. */
+  faint: string
+  /** Chip fill and stroke: ink at a few percent. */
+  fill: string
+  stroke: string
+  accent: string
+  /** The accent as a wash behind a lit control. */
+  accentWash: string
+  accentLine: string
+  /** Fill of a primary action, white text on it. */
+  primary: string
+  ok: string
+  warn: string
+  bad: string
+}
+
+export const ACCENT = '#6a56d6'
+
+export const DARK: Palette = {
+  ink: '#ecebf2',
+  muted: '#a19fae',
+  faint: '#55535f',
+  fill: 'rgba(236,235,242,0.045)',
+  stroke: 'rgba(236,235,242,0.13)',
+  accent: '#a594f5',
+  accentWash: 'rgba(150,130,245,0.17)',
+  accentLine: 'rgba(165,148,245,0.62)',
+  primary: '#6f5bdc',
+  ok: '#3ecb7d',
+  warn: '#e0b436',
+  bad: '#ef5a5a',
+}
+
+export const LIGHT: Palette = {
+  ink: '#1d1b26',
+  muted: '#64616f',
+  faint: '#c9c6d2',
+  fill: 'rgba(29,27,38,0.035)',
+  stroke: 'rgba(29,27,38,0.13)',
+  accent: '#6a56d6',
+  accentWash: 'rgba(106,86,214,0.10)',
+  accentLine: 'rgba(106,86,214,0.55)',
+  primary: '#6a56d6',
+  ok: '#1a8a4a',
+  warn: '#b5820a',
+  bad: '#c73434',
+}
+
+/**
+ * Colours for native Text, which the host draws on its own background. With appearance auto the
+ * mod cannot know that background, so these are mid tones that read on both.
+ */
+export const TEXT = {
+  accent: '#7c69e0',
+  ok: '#16a34a',
+  warn: '#d97706',
+  bad: '#dc2626',
+}
+
+export function textTone(appearance: Appearance): typeof TEXT {
+  if (appearance === 'dark') return { accent: DARK.accent, ok: DARK.ok, warn: DARK.warn, bad: DARK.bad }
+  if (appearance === 'light') return { accent: LIGHT.accent, ok: LIGHT.ok, warn: LIGHT.warn, bad: LIGHT.bad }
+  return TEXT
+}
+
+// A provider is named by whoever added it, so most names are not known here. The presets' default
+// names keep their vendor's hue; any other name gets one from PALETTE picked by a hash of the name,
+// so it keeps that colour from one session to the next. The palette leaves out the status
+// red/green/amber, so a provider is never read as a result.
+const KNOWN: Record<string, string> = {
+  anthropic: '#d97757',
+  chatgpt: '#10a37f',
+  'google-gemini': '#4285f4',
+  deepseek: '#4d6bfe',
+  'opencode-go': '#9333ea',
+  'opencode-zen': '#9333ea',
+}
+const PALETTE = ['#0891b2', '#db2777', '#7c3aed', '#0d9488', '#c026d3', '#4f46e5', '#0284c7', '#be185d']
+
+export function providerColor(provider: string): string {
+  if (provider === 'refused') return TEXT.bad
+  const known = KNOWN[provider]
+  if (known) return known
+  let hash = 0
+  for (const char of provider) hash = (hash * 31 + char.charCodeAt(0)) >>> 0
+  return PALETTE[hash % PALETTE.length]!
+}
+
+/** Worker tiers keep one hue each, away from the status colours and from each other. */
+export const TIER_HUE: Record<'light' | 'standard' | 'deep' | 'design', string> = {
+  light: '#0891b2',
+  standard: '#6a56d6',
+  deep: '#be185d',
+  design: '#d97757',
+}
+
+// The acceptance bar for translated providers is a 90% cache hit.
+export function cacheTone(percent: number): 'ok' | 'warn' | 'bad' {
+  return percent >= 90 ? 'ok' : percent >= 50 ? 'warn' : 'bad'
+}
+
+/** Context fill: neutral until the swamp line, amber past it, red from 85%. */
+export function contextTone(percent: number, swampAt: number): 'ink' | 'warn' | 'bad' {
+  return percent >= 85 ? 'bad' : percent >= swampAt ? 'warn' : 'ink'
+}
+
+/** Plan window: neutral under 80%, amber to 95%, red above. */
+export function limitTone(percent: number): 'ink' | 'warn' | 'bad' {
+  return percent >= 95 ? 'bad' : percent >= 80 ? 'warn' : 'ink'
+}
+
+// ---- SVG ------------------------------------------------------------------------------------
+
+const VARS: (keyof Palette)[] = ['ink', 'muted', 'faint', 'fill', 'stroke', 'accent', 'accentWash', 'accentLine', 'primary', 'ok', 'warn', 'bad']
+
+function varsOf(p: Palette): string {
+  return VARS.map(k => '--' + k + ':' + p[k]).join(';')
+}
+
+/** `var(--name)` for a palette key: what SVG markup paints with. */
+export function v(key: keyof Palette): string {
+  return 'var(--' + key + ')'
+}
+
+const FONT = "-apple-system,BlinkMacSystemFont,'SF Pro Text','Segoe UI',system-ui,sans-serif"
+
+/**
+ * One SVG document. The palette is set as CSS variables on the root: fixed for dark or light, and
+ * for auto switched by the frame's `prefers-color-scheme`. `viewBox` draws a grid of its own at
+ * this size (the mascot's 56 units); absent, one unit is one pixel.
+ */
+export function svgDoc(width: number, height: number, appearance: Appearance, body: string, css = '', viewBox = '0 0 ' + width + ' ' + height): string {
+  const vars =
+    appearance === 'dark'
+      ? 'svg{' + varsOf(DARK) + '}'
+      : appearance === 'light'
+        ? 'svg{' + varsOf(LIGHT) + '}'
+        : 'svg{' + varsOf(LIGHT) + '}@media (prefers-color-scheme:dark){svg{' + varsOf(DARK) + '}}'
+  const base =
+    'text{font-family:' + FONT + ';font-variant-numeric:tabular-nums;fill:var(--ink)}' +
+    '.cap{font-size:8.5px;letter-spacing:.09em;font-weight:600;fill:var(--muted)}' +
+    '.val{font-size:12.5px;font-weight:600}' +
+    '.sub{font-size:11.5px;fill:var(--muted)}' +
+    '.lbl{font-size:12px;font-weight:500}'
+  return (
+    '<svg xmlns="http://www.w3.org/2000/svg" width="' + width + '" height="' + height +
+    '" viewBox="' + viewBox + '"><style>' + vars + base + css + '</style>' + body + '</svg>'
+  )
+}
+
+// East Asian Wide and Fullwidth ranges (UAX #11), and the emoji planes terminals draw two wide.
+const WIDE = /[ᄀ-ᅟ⌚⌛〈〉⏩-⏬⏰⏳◽◾☔☕♈-♓♿⚓⚡⚪⚫⚽⚾⛄⛅⛎⛔⛪⛲⛳⛵⛺⛽✅✊✋✨❌❎❓-❕❗➕-➗➰➿⬛⬜⭐⭕⺀-〾ぁ-㏿㐀-䶿一-鿿ꀀ-꓏ꥠ-꥿가-힣豈-﫿︐-︙︰-﹯＀-｠￠-￦\u{16FE0}-\u{16FE4}\u{17000}-\u{18CFF}\u{1B000}-\u{1B2FF}\u{1F004}\u{1F0CF}\u{1F18E}\u{1F191}-\u{1F19A}\u{1F200}-\u{1F251}\u{1F300}-\u{1F64F}\u{1F680}-\u{1F6FF}\u{1F7E0}-\u{1F7EB}\u{1F90C}-\u{1F9FF}\u{1FA70}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u
+// Combining marks, zero-width spaces and joiners, variation selectors: no cell of their own.
+const ZERO = /[\p{Mn}\p{Me}​-‏⁠-⁤︀-️]/u
+
+/** Terminal cells a code point takes: 2 for East Asian Wide/Fullwidth, 0 for combining and controls, else 1. */
+function cellWidth(char: string): number {
+  const code = char.codePointAt(0)!
+  if (code < 0x20 || (code >= 0x7f && code < 0xa0)) return 0
+  if (ZERO.test(char)) return 0
+  return WIDE.test(char) ? 2 : 1
+}
+
+/** Terminal columns `text` takes: East Asian Wide/Fullwidth count 2, combining marks 0. */
+export function displayWidth(text: string): number {
+  let width = 0
+  for (const char of text) width += cellWidth(char)
+  return width
+}
+
+/**
+ * The desktop width of `text` in `ch`, unrounded: the host's `ch` is the width of "0" in its 14 px
+ * sans. Measured 2026-10-10 in Chromium on macOS: ch 8.8 px, Hangul and kana ~12 px (1.36 ch),
+ * "Medium" 5.9 ch, "X-High" 5.1 ch. Each class of character is taken a little wide of that.
+ */
+export function chOf(text: string): number {
+  let ch = 0
+  for (const char of text) {
+    if (displayWidth(char) === 2) ch += 1.45
+    else if (char === ' ') ch += 0.45
+    else if (/[ilIj.,:;|'!]/.test(char)) ch += 0.4
+    else if (/[mwMW@%]/.test(char)) ch += 1.35
+    else if (/[A-Z]/.test(char)) ch += 1.1
+    else if (/[0-9]/.test(char)) ch += 1
+    else ch += 0.85
+  }
+  return ch
+}
+
+/** Cuts text to at most `max` terminal columns, the ellipsis included. */
+export function clip(text: string, max: number): string {
+  if (displayWidth(text) <= max) return text
+  const room = Math.max(1, max - 1)
+  let out = ''
+  let used = 0
+  for (const char of text) {
+    const w = cellWidth(char)
+    if (used + w > room) break
+    out += char
+    used += w
+  }
+  return out + '…'
+}

package/dist/mod/hooks/ui/view.ts

@@ -0,0 +1,371 @@
+// What the drawings take: view models register.tsx fills from the mod's state atoms, and the
+// callbacks it hands in. Every renderer in ./ is a pure function of (elements, view, actions);
+// none of them calls the engine, so they can be drawn and tested anywhere.
+
+import type { AgentRec, Effort, HandoffKind, JudgeKind, JudgeRun, LadderOptions, Pick, Settings, StatusRequest, TierTarget } from '../../types'
+import type { Appearance } from './theme'
+import { t } from '../i18n'
+import type { Lang } from '../i18n'
+
+export type Surface = 'terminal' | 'desktop' | 'vscode' | 'mobile'
+
+/** Where and how big: from `e.surface`, `e.props.bodyColumns` / `maxRows`, the clock and settings. */
+export type Frame = {
+  surface: Surface
+  /** Cells across (`bodyColumns`). */
+  columns: number
+  /** Rows the band may take (`maxRows`); a pane passes its `scroll.bodyRows`. */
+  maxRows: number
+  /** Epoch ms when drawn; countdowns are computed from it. */
+  now: number
+  appearance: Appearance
+  lang: Lang
+}
+
+/** Desktop and the editor draw SVG; the terminal and mobile draw text. */
+export function isRich(frame: Frame): boolean {
+  return frame.surface === 'desktop' || frame.surface === 'vscode'
+}
+
+// ---- Dashboard -------------------------------------------------------------------------------
+
+/**
+ * auto: Auto picked it · deciding: the judge is thinking · paused: Auto cannot run on this model ·
+ * off: Auto is off (the level is the app's) · manual: the person picked the level.
+ */
+export type EffortMode = 'auto' | 'deciding' | 'paused' | 'off' | 'manual'
+
+export type RouteView = {
+  /** `target`, or `target (requested)` when the router swapped it. */
+  model: string
+  provider: string
+  ok: boolean
+  resent: boolean
+  status: string
+  effort?: string
+  /** Prompt tokens read from cache, in percent. */
+  cachePct?: number
+  seconds: number
+  note?: string
+}
+
+export type DashboardView = {
+  effort: {
+    level: Effort | null
+    mode: EffortMode
+    /** The judge's reason, a few words. */
+    why?: string
+    /** Who gave it. */
+    by?: Pick['by']
+    /** When the judge started (deciding): keeps the glow's phase across redraws. */
+    since?: number
+  }
+  /** Display name of the main chat's model ("Opus 5.5"); see modelName. */
+  model: string | null
+  context: { percent: number; tokens: number; window: number } | null
+  /** The last main reply's cache; null when unknown. */
+  cache: { expiresAt: number; ttlMs: number } | null
+  warm: { on: boolean; pings: number; cost: number; stopped?: string }
+  /** The hottest plan window, shown when present. */
+  limit: { kind: string; percent: number; resetsAt?: string; save: boolean } | null
+  route: RouteView | null
+  /** A line from the router side ("router not answering"), shown in place of the route. */
+  notice: string | null
+  auto: boolean
+  /** Compact turns into a lit Handoff when advice says so, or always with handoffButton 'always'. */
+  handoff: 'off' | 'advised' | 'always'
+  agents: { live: number; total: number }
+  logOpen: boolean
+  agentsOpen: boolean
+  /** The manual effort row is open. */
+  effortMenu: boolean
+  /** Context percent at which the swamp colour starts (settings.swampAt). */
+  swampAt: number
+  /** Band parts switched off: 'timer' | 'reason' | 'route'. */
+  hide: readonly string[]
+  /** Optional chips switched on: 'context' | 'limits'. */
+  extras: readonly string[]
+  isWorking: boolean
+  /** The active operating mode's name; absent when none is on. */
+  mode?: string
+}
+
+export type BandActions = {
+  toggleAuto: () => void
+  toggleWarm: () => void
+  compact: () => void
+  handoff: () => void
+  toggleLog: () => void
+  toggleAgents: () => void
+  openSettings: () => void
+  /** Opens or closes the manual effort row. */
+  toggleEffortMenu: () => void
+  /** A manual pick: Auto steps aside for it (spec §1 "Person wins"). */
+  pickEffort: (effort: Effort) => void
+  /** Hides the band (desktop: its × is drawn inside the band). */
+  hide?: () => void
+}
+
+// ---- Alerts and cards ------------------------------------------------------------------------
+
+export type ResultStage = 'handingOff' | 'handoffReady' | 'handoffDone' | 'compacting' | 'compacted' | 'failed'
+
+export type AlertView =
+  /** The cache expired on a big chat: the next prompt re-reads it all. */
+  | { kind: 'cold'; tokens: number; idleMinutes: number }
+  /** Context is heavy. */
+  | { kind: 'swamp'; percent: number; tokens: number }
+  /** A plan window at or above 80%. */
+  | { kind: 'hot'; limitKind: string; percent: number; resetsAt?: string; save: boolean }
+  /** The judge failed and Auto fell back. */
+  | { kind: 'judgeDown'; judge: JudgeKind; reason: string; network?: boolean }
+  | { kind: 'result'; stage: ResultStage; handoffKind?: HandoffKind; detail?: string }
+  /** Compact with an optional note of what to keep. */
+  | { kind: 'compactNote'; draft: string }
+  /** Quick or full handoff, and what happens after. */
+  | { kind: 'handoffChoice'; handoffKind: HandoffKind; after: Settings['handoffAfter'] }
+
+export type AlertActions = {
+  compact: (note?: string) => void
+  /** Opens the handoff choice bar. */
+  handoff: () => void
+  dismiss: () => void
+  toggleSave: () => void
+  openSettings: () => void
+  /** Each change of the compact note's field. */
+  noteInput: (text: string) => void
+  setHandoffKind: (kind: HandoffKind) => void
+  setHandoffAfter: (after: Settings['handoffAfter']) => void
+  go: () => void
+  /** Copies a handoff's text again (result card, after: copy). */
+  copy: () => void
+  /** Opens a new session in this folder with the written handoff (Confirm first's card). */
+  openNew: () => void
+}
+
+// ---- Settings and setup ----------------------------------------------------------------------
+
+export type JevState = {
+  /** Where the key comes from; null when there is none. */
+  source: 'env' | 'file' | 'pasted' | 'zen' | null
+  test: { state: 'idle' | 'testing' | 'ok' | 'fail'; message?: string }
+}
+
+export type SettingsView = {
+  settings: Settings
+  jev: JevState
+  /** What each rung can run (the ticked models); null until the router has answered. */
+  ladder?: LadderOptions | null
+}
+
+export type SettingsActions = {
+  /** Applies and saves each change immediately. */
+  patch: (change: Partial<Settings>) => void
+  /** Turns a mode on by id, or every mode off with ''. */
+  setMode?: (id: string) => void
+  /** The Jev key typed into the field (Enter). */
+  jevKey: (key: string) => void
+  testJev: () => void
+  openAllSettings: () => void
+  close: () => void
+}
+
+export type SetupStep = 1 | 2 | 3 | 4
+
+export type SetupView = {
+  step: SetupStep
+  draft: Settings
+  jev: JevState
+}
+
+export type SetupActions = {
+  patch: (change: Partial<Settings>) => void
+  jevKey: (key: string) => void
+  testJev: () => void
+  openAllSettings: () => void
+  back: () => void
+  next: () => void
+  /** Saves the draft with setupDone and closes. */
+  finish: () => void
+  /** Closes with the defaults, setupDone. */
+  skip: () => void
+}
+
+// ---- Panes -----------------------------------------------------------------------------------
+
+export type AgentsView = {
+  agents: readonly AgentRec[]
+  now: number
+  showDone: boolean
+}
+
+export type AgentsActions = {
+  toggleDone: () => void
+}
+
+export type LogView = {
+  rows: readonly StatusRequest[]
+  mineOnly: boolean
+  /** This session's verdicts, listed among its requests. */
+  judges?: readonly JudgeRun[]
+}
+
+export type LogActions = {
+  toggleScope: () => void
+}
+
+// ---- Helpers register.tsx and the drawings share ----------------------------------------------
+
+export const EFFORTS: readonly Effort[] = ['low', 'medium', 'high', 'xhigh', 'max']
+
+export function effortIndex(effort: Effort | null | undefined): number {
+  return effort ? EFFORTS.indexOf(effort) : -1
+}
+
+export function effortName(effort: Effort, lang: Lang): string {
+  return t(lang, 'band.' + effort)
+}
+
+/** Route records can contain unknown effort ids; translate only the known display values. */
+export function effortLabel(value: string, lang: Lang): string {
+  return EFFORTS.includes(value as Effort) ? effortName(value as Effort, lang).toLowerCase() : value
+}
+
+/** "claude-opus-5-5[1m]" → "Opus 5.5"; ids it does not know pass through, trimmed. */
+export function modelName(id: string): string {
+  const bare = id.replace(/\[.*?\]/g, '').replace(/^claude-/, '')
+  const m = /^(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2}))?/.exec(bare)
+  if (m) return m[1]!.charAt(0).toUpperCase() + m[1]!.slice(1) + ' ' + m[2] + (m[3] ? '.' + m[3] : '')
+  // A bare alias ("sonnet") reads as its family's name.
+  if (/^(opus|sonnet|haiku|fable)\b/.test(bare) && !bare.includes('-')) return bare.charAt(0).toUpperCase() + bare.slice(1)
+  return bare
+}
+
+/** A TierTarget as one Select value: `agent` or `agent+model`. */
+export function targetValue(target: TierTarget): string {
+  return target.model ? target.agent + '+' + target.model : target.agent
+}
+
+export function targetOf(value: string): TierTarget {
+  const plus = value.indexOf('+')
+  return plus < 0 ? { agent: value } : { agent: value.slice(0, plus), model: value.slice(plus + 1) }
+}
+
+/**
+ * A target as a person reads it: the model for Claude's own agents, else the agent; Claude's agent
+ * with no model runs on the session's model and says so.
+ */
+export function targetLabel(target: TierTarget, lang?: Lang): string {
+  if (target.model) return 'Claude ' + modelName(target.model)
+  return lang && target.agent === 'general-purpose' ? t(lang, 'workers.sessionModel') : target.agent
+}
+
+type Usage = NonNullable<StatusRequest['usage']>
+
+export function promptTokens(usage: Usage): number {
+  return usage.input + usage.cached + (usage.cacheWrite ?? 0)
+}
+
+export function cachePercent(usage: Usage | undefined): number | undefined {
+  if (!usage) return undefined
+  const prompt = promptTokens(usage)
+  return prompt > 0 ? Math.round((usage.cached / prompt) * 100) : undefined
+}
+
+// The requested name's `@effort` is the agent file's default, not what was sent; the sent effort is
+// its own field.
+export function modelOf(record: StatusRequest): string {
+  const at = record.source.lastIndexOf('@')
+  const source = at < 0 ? record.source : record.source.slice(0, at)
+  // A dated id of the same model (claude-haiku-5-5-20260815 for claude-haiku-5-5) says nothing new.
+  return source.startsWith(record.target) || record.target.startsWith(source) ? record.target : record.target + ' (' + source + ')'
+}
+
+export function routeOf(record: StatusRequest): RouteView {
+  const route: RouteView = {
+    model: modelOf(record),
+    provider: record.provider,
+    ok: record.ok,
+    resent: record.resent === true,
+    status: String(record.status),
+    seconds: record.ms / 1000,
+  }
+  const cache = cachePercent(record.usage)
+  if (record.effort) route.effort = record.effort
+  if (cache !== undefined) route.cachePct = cache
+  if (record.note) route.note = record.note
+  return route
+}
+
+/** 1234 → "1.2k", 1_200_000 → "1.2M". */
+export function compactNumber(n: number): string {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + 'M'
+  if (n >= 10_000) return Math.round(n / 1000) + 'k'
+  if (n >= 1000) return (n / 1000).toFixed(1) + 'k'
+  return String(Math.round(n))
+}
+
+/** A countdown as the band shows it: "58m" above two minutes, "1:45" below, "cold" at zero. */
+export function countdown(ms: number, lang: Lang): string {
+  if (ms <= 0) return t(lang, 'band.cold')
+  const s = Math.ceil(ms / 1000)
+  if (s >= 120) return t(lang, 'units.minutes', { n: Math.ceil(s / 60) })
+  return Math.floor(s / 60) + ':' + String(s % 60).padStart(2, '0')
+}
+
+/**
+ * The cache countdown as the band and the footer show it: whole minutes rounded up ("42m" … "1m"),
+ * "cold" at zero. It changes once a minute, so the band redraws at most once a minute for it.
+ */
+export function minutesLeft(ms: number, lang: Lang): string {
+  if (ms <= 0) return t(lang, 'band.cold')
+  return t(lang, 'units.minutes', { n: Math.ceil(ms / 60_000) })
+}
+
+/** When minutesLeft next changes for a cache expiring at `expiresAt` (epoch ms); null once cold. */
+export function nextMinuteChange(expiresAt: number, now: number): number | null {
+  const left = expiresAt - now
+  if (left <= 0) return null
+  return expiresAt - (Math.ceil(left / 60_000) - 1) * 60_000
+}
+
+/** A duration the Agents pane shows: "12s", "4m 05s", "1h 02m". */
+export function elapsed(ms: number, lang: Lang): string {
+  const s = Math.max(0, Math.floor(ms / 1000))
+  if (s < 60) return t(lang, 'units.seconds', { n: s })
+  const m = Math.floor(s / 60)
+  if (m < 60) return t(lang, 'units.minSec', { m, s: String(s % 60).padStart(2, '0') })
+  return t(lang, 'units.hourMin', { h: Math.floor(m / 60), m: String(m % 60).padStart(2, '0') })
+}
+
+/** Seconds with one decimal, as routes and log entries show them: "1.2s". */
+export function seconds(value: number, lang: Lang): string {
+  return t(lang, 'units.seconds', { n: value.toFixed(1) })
+}
+
+export function clockTime(at: string | number): string {
+  const date = new Date(at)
+  return [date.getHours(), date.getMinutes(), date.getSeconds()].map(n => String(n).padStart(2, '0')).join(':')
+}
+
+/** "resets 14:20" or "resets in 3h" from an ISO time. */
+export function resetsLabel(resetsAt: string | undefined, now: number, lang: Lang): string | undefined {
+  if (!resetsAt) return undefined
+  const at = Date.parse(resetsAt)
+  if (!Number.isFinite(at)) return undefined
+  const left = at - now
+  if (left <= 0) return t(lang, 'band.resetting')
+  if (left < 3_600_000) return t(lang, 'band.resetsIn', { time: t(lang, 'units.minutes', { n: Math.max(1, Math.round(left / 60_000)) }) })
+  if (left < 86_400_000) {
+    const d = new Date(at)
+    return t(lang, 'band.resetsAt', { time: String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0') })
+  }
+  return t(lang, 'band.resetsIn', { time: t(lang, 'units.days', { n: Math.round(left / 86_400_000) }) })
+}
+
+/** "five_hour" → "5-hour", "seven_day" → "Weekly". */
+export function limitName(kind: string, lang: Lang): string {
+  if (kind === 'five_hour') return t(lang, 'band.fiveHour')
+  if (kind === 'seven_day') return t(lang, 'band.weekly')
+  return kind.replace(/_/g, ' ')
+}

package/dist/mod/hooks/worker.ts

@@ -11,7 +11,7 @@
 // `deepseek-v4.1-flash@low` runs the worker on that id, and the router records effort low.
 
 /** The router's marker, found anywhere in the prompt rather than only at its top. */
-const MARKER = /\[\[\s*(?:ripple|gpt)\s*:\s*([A-Za-z0-9.\-]+)\s*(?:@\s*([A-Za-z]+))?\s*\]\]/
+export const MARKER = /\[\[\s*(?:ripple|gpt)\s*:\s*([A-Za-z0-9.\-]+)\s*(?:@\s*([A-Za-z]+))?\s*\]\]/
 
 export type Spawn = { subagentType: string; prompt: string; model?: string }
 export type WorkerFix = { prompt: string; model: string; dropped?: string }