clauderipple 0.9.5 → 0.10.0

package/dist/mod/hooks/session.ts

@@ -1,5 +1,5 @@
 import type { SessionContextUsage, SessionRateLimit } from 'claude-code'
-import type { CacheMemo, Hot } from '../types'
+import type { CacheMemo, Hot, LimitItem } from '../types'
 
 export function hottest(rateLimits: readonly SessionRateLimit[]): Hot | null {
   const eligible = rateLimits.filter(limit => ['five_hour', 'seven_day'].includes(limit.kind) && limit.percentUsed >= 80)
@@ -33,6 +33,88 @@ export function claudeLimitsFrom(status: unknown, now: number): SessionRateLimit
   })
 }
 
+/** One per-model weekly window the router reports beside `rate_limits` (see `scopedFromLimits`). */
+export type ScopedLimit = { name: string; percent: number; resetsAt?: string }
+
+/**
+ * The per-model weekly windows of the Claude login, from the router's GET /api/status
+ * (`claude.accounts[id=current].quota.scoped`: `{name, used_percent, window_minutes, reset_at}`,
+ * reset in epoch seconds or ms). A stale or unknown snapshot gives nothing, like claudeLimitsFrom.
+ */
+export function claudeScopedFrom(status: unknown, now: number): ScopedLimit[] {
+  const object = (v: unknown): Record<string, unknown> => v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : {}
+  const accounts = object(object(status).claude).accounts
+  const current = Array.isArray(accounts) ? accounts.map(object).find(a => a.id === 'current') : undefined
+  const quota = object(current?.quota)
+  if (typeof quota.at !== 'number' || now - quota.at > CLAUDE_USAGE_STALE_MS) return []
+  const scoped = quota.scoped
+  if (!Array.isArray(scoped)) return []
+  return scoped.map(object).flatMap(entry => {
+    if (typeof entry.name !== 'string' || !entry.name || typeof entry.used_percent !== 'number' || !Number.isFinite(entry.used_percent)) return []
+    const reset = typeof entry.reset_at === 'number' ? entry.reset_at * (entry.reset_at < 1e12 ? 1000 : 1) : NaN
+    return [{ name: entry.name, percent: Math.round(entry.used_percent * 10) / 10, ...(Number.isFinite(reset) ? { resetsAt: new Date(reset).toISOString() } : {}) }]
+  })
+}
+
+const KINDS = ['five_hour', 'seven_day', 'scoped', 'window'] as const
+type LimitKind = (typeof KINDS)[number]
+
+/** One window of `GET /api/limits` as a limits-row item, or null when it carries nothing to show. */
+function limitItemFromWindow(w: unknown, provider: string, type: string | undefined, title: string | undefined, account: number, now: number): LimitItem | null {
+  const o = w && typeof w === 'object' && !Array.isArray(w) ? w as Record<string, unknown> : {}
+  const kind = o.kind
+  if (typeof kind !== 'string' || !(KINDS as readonly string[]).includes(kind)) return null
+  const used = o.used_percent
+  if (typeof used !== 'number' || !Number.isFinite(used)) return null
+  const minutes = typeof o.window_minutes === 'number' && o.window_minutes > 0 ? o.window_minutes : undefined
+  const reset = typeof o.reset_at === 'number' && Number.isFinite(o.reset_at) ? o.reset_at * (o.reset_at < 1e12 ? 1000 : 1) : NaN
+  // A window whose reset has passed no longer stands (as the ChatGPT reader has always said).
+  if (Number.isFinite(reset) && reset <= now) return null
+  return {
+    provider,
+    ...(type ? { type } : {}),
+    ...(title ? { title } : {}),
+    account,
+    kind: kind as LimitKind,
+    label: typeof o.label === 'string' ? o.label : '',
+    ...(minutes !== undefined ? { windowMinutes: minutes } : {}),
+    percent: Math.round(used * 10) / 10,
+    ...(Number.isFinite(reset) ? { resetsAt: new Date(reset).toISOString() } : {}),
+  }
+}
+
+/**
+ * Every provider's windows from the router's `GET /api/limits`: one shape for Claude, each ChatGPT
+ * account and each Antigravity account (see `buildLimits` in packages/router/src/admin.ts). The
+ * providers keep the router's order (Claude first), and each account's windows keep theirs.
+ */
+export function routerLimitItems(body: unknown, now: number): LimitItem[] {
+  const object = (v: unknown): Record<string, unknown> => v && typeof v === 'object' && !Array.isArray(v) ? v as Record<string, unknown> : {}
+  const providers = object(body).providers
+  if (!Array.isArray(providers)) return []
+  const out: LimitItem[] = []
+  for (const p of providers) {
+    const entry = object(p)
+    const provider = typeof entry.provider === 'string' ? entry.provider : ''
+    if (!provider) continue
+    const type = typeof entry.type === 'string' ? entry.type : undefined
+    const title = typeof entry.title === 'string' ? entry.title : undefined
+    const accounts = entry.accounts
+    if (!Array.isArray(accounts)) continue
+    for (const a of accounts) {
+      const account = object(a)
+      const index = typeof account.account === 'number' ? account.account : 0
+      const windows = account.windows
+      if (!Array.isArray(windows)) continue
+      for (const w of windows) {
+        const item = limitItemFromWindow(w, provider, type, title, index, now)
+        if (item) out.push(item)
+      }
+    }
+  }
+  return out
+}
+
 /**
  * The reset is read in the person's own clock: `offsetMinutes` is `Date#getTimezoneOffset` (minutes
  * behind UTC), passed in so tests do not depend on the machine's zone.
@@ -71,6 +153,21 @@ export function keptAlert(kept: { pings: number; tokens: number } | null, memo:
   return kept !== null && kept.pings > 0 && memo !== null && memo.expiresAt > now
 }
 
+/**
+ * Whether a put-off hot card should be forgotten: only when the window itself has moved on — another
+ * window became the hottest, or its reset moved forward by more than an hour. A reading that is
+ * missing for a while (a routed model's session carries no plan windows) or that comes from the
+ * other source with its reset spelled to the second rather than the minute is the same window, and
+ * forgetting on either brought the card back on every turn (2026-10-14, weekly at 87%).
+ */
+export function hotWindowMoved(previous: Hot | null, next: Hot | null): boolean {
+  if (!previous || !next) return false
+  if (previous.kind !== next.kind) return true
+  const before = previous.resetsAt ? Date.parse(previous.resetsAt) : NaN
+  const after = next.resetsAt ? Date.parse(next.resetsAt) : NaN
+  return Number.isFinite(before) && Number.isFinite(after) && after - before > 3_600_000
+}
+
 export function hotAlert(hot: Hot | null, hidden: number | null): boolean {
   return hot !== null && hot.percent >= 80 && (hidden === null || hot.percent >= hidden + 10)
 }

package/dist/mod/hooks/settings.js

@@ -26,13 +26,17 @@ export const DEFAULTS = {
     fallback: { agent: 'general-purpose', model: 'sonnet' },
     keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
     compactWith: 'haiku', handoffSkill: '', handoffAfter: 'continue', handoffButton: 'advised',
-    swampAt: 50, swampAlert: false, layout: 'dashboard', appearance: 'auto', language: 'auto', hide: ['reason'], extras: [], setupDone: false,
+    swampAt: 50, swampAlert: false, layout: 'dashboard', appearance: 'auto', skin: 'deep', language: 'auto', hide: ['reason'], extras: [], setupDone: false,
 };
+/** The desktop's skins, in the order the panel offers them. */
+export const SKINS = ['deep', 'flat'];
 /** Band chips that show only when switched on in Look. */
 export const EXTRAS = ['context', 'limits'];
 /**
  * Claude's own models as workers: the built-in general-purpose agent run on the model, `model` its
- * current id. The key is what the allow-list stores.
+ * current id. The key is what the allow-list stores. Mythos is not here: the Agent tool's `model`
+ * takes only sonnet, opus, haiku and fable (Claude Code 2.1.295, read 2026-10-14), so a
+ * general-purpose worker on it would be refused.
  */
 export const CLAUDE_WORKERS = [
     { name: 'general-purpose:haiku', model: 'claude-haiku-5-5', provider: 'anthropic', target: { agent: 'general-purpose', model: 'haiku' } },
@@ -281,7 +285,7 @@ export function normalizeSettings(raw, workers) {
         judge: ['haiku', 'jev', 'model'], jevSource: ['typesafe', 'zen'], bias: [-2, -1, 0, 1, 2], floor: EFFORTS,
         ceiling: EFFORTS, agentAuto: ['off', 'auto', 'all'], keepWarmHours: [1, 2, 4, 8], compactWith: ['haiku', 'session'],
         handoffAfter: ['continue', 'confirm', 'copy'], handoffButton: ['advised', 'always'], layout: ['dashboard', 'minimal'],
-        appearance: ['auto', 'dark', 'light'], language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
+        appearance: ['auto', 'dark', 'light'], skin: SKINS, language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
     };
     for (const key of Object.keys(choices))
         if (choices[key].includes(value[key]))

package/dist/mod/hooks/settings.ts

@@ -1,4 +1,4 @@
-import type { Calibration, Domain, Effort, Level, Mode, Rule, Rung, Settings, SettingsChange, Step, TierTarget } from '../types/index.d.ts'
+import type { Calibration, Domain, Effort, Level, Mode, Rule, Rung, Settings, SettingsChange, Skin, Step, TierTarget } from '../types/index.d.ts'
 
 /** Bump whenever a writer's normalization can lose another format's fields. */
 export const MOD_SETTINGS_SCHEMA_VERSION = 1
@@ -31,15 +31,20 @@ export const DEFAULTS: Settings = {
   fallback: { agent: 'general-purpose', model: 'sonnet' },
   keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
   compactWith: 'haiku', handoffSkill: '', handoffAfter: 'continue', handoffButton: 'advised',
-  swampAt: 50, swampAlert: false, layout: 'dashboard', appearance: 'auto', language: 'auto', hide: ['reason'], extras: [], setupDone: false,
+  swampAt: 50, swampAlert: false, layout: 'dashboard', appearance: 'auto', skin: 'deep', language: 'auto', hide: ['reason'], extras: [], setupDone: false,
 }
 
+/** The desktop's skins, in the order the panel offers them. */
+export const SKINS: readonly Skin[] = ['deep', 'flat']
+
 /** Band chips that show only when switched on in Look. */
 export const EXTRAS: readonly string[] = ['context', 'limits']
 
 /**
  * Claude's own models as workers: the built-in general-purpose agent run on the model, `model` its
- * current id. The key is what the allow-list stores.
+ * current id. The key is what the allow-list stores. Mythos is not here: the Agent tool's `model`
+ * takes only sonnet, opus, haiku and fable (Claude Code 2.1.295, read 2026-10-14), so a
+ * general-purpose worker on it would be refused.
  */
 export const CLAUDE_WORKERS: readonly { name: string; model: string; provider: string; target: TierTarget }[] = [
   { name: 'general-purpose:haiku', model: 'claude-haiku-5-5', provider: 'anthropic', target: { agent: 'general-purpose', model: 'haiku' } },
@@ -272,7 +277,7 @@ export function normalizeSettings(raw: unknown, workers?: readonly Worker[]): Se
     judge: ['haiku', 'jev', 'model'], jevSource: ['typesafe', 'zen'], bias: [-2, -1, 0, 1, 2], floor: EFFORTS,
     ceiling: EFFORTS, agentAuto: ['off', 'auto', 'all'], keepWarmHours: [1, 2, 4, 8], compactWith: ['haiku', 'session'],
     handoffAfter: ['continue', 'confirm', 'copy'], handoffButton: ['advised', 'always'], layout: ['dashboard', 'minimal'],
-    appearance: ['auto', 'dark', 'light'], language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
+    appearance: ['auto', 'dark', 'light'], skin: SKINS, language: ['auto', 'ko', 'en', 'zh', 'ja', 'es', 'pt'],
   } as const
   for (const key of Object.keys(choices) as (keyof typeof choices)[]) if ((choices[key] as readonly unknown[]).includes(value[key])) Object.assign(result, { [key]: value[key] })
   if (typeof value.judgeModel === 'string' && value.judgeModel.trim()) result.judgeModel = value.judgeModel.trim()

package/dist/mod/hooks/stats.ts

@@ -1,4 +1,4 @@
-import type { Effort, JudgeKind, Stats, Tier, Usage } from '../types'
+import type { AgentRec, Effort, JudgeKind, Stats, Tier, Usage } from '../types'
 import { t } from './i18n.ts'
 import type { Lang } from './i18n.ts'
 
@@ -13,6 +13,30 @@ export function weighted(usage: Usage): number {
     (usage.cache_read_input_tokens ?? 0) * 0.1 + (usage.output_tokens ?? 0) * 5
 }
 
+/**
+ * The effort a step was sent at: a routed id's `@effort` wins, since the router forces it over the
+ * request's own (packages/router/src/routing.ts: "gpt-5.6-sol@medium → effort forced to medium").
+ */
+export function sentEffort(model: string, effort: string | number | undefined): string | number | undefined {
+  return /@([a-z]+)$/.exec(model)?.[1] ?? effort
+}
+
+/**
+ * An agent after one of its steps: the raw counts the API reported added to its own (what the
+ * Agents pane shows, so it agrees with the host's), the weighted cost as before, the effort the step
+ * was sent at and the model that answered.
+ */
+export function addAgentStep(agent: AgentRec, usage: Usage & { model?: string }, effort: string | number | undefined): AgentRec {
+  const was = agent.usage ?? { input: 0, cached: 0, cacheWrite: 0, output: 0 }
+  return {
+    ...agent,
+    cost: agent.cost + weighted(usage),
+    usage: { input: was.input + (usage.input_tokens ?? 0), cached: was.cached + (usage.cache_read_input_tokens ?? 0), cacheWrite: was.cacheWrite + (usage.cache_creation_input_tokens ?? 0), output: was.output + (usage.output_tokens ?? 0) },
+    ...(effort !== undefined ? { effort } : {}),
+    ...(usage.model ? { answeredBy: usage.model } : {}),
+  }
+}
+
 export function addRequest(stats: Stats, usage: Usage, effort: Effort): Stats {
   const bucket = stats.byEffort[effort] ?? { prompts: 0, cost: 0 }
   return { ...stats, requests: stats.requests + 1, input: stats.input + (usage.input_tokens ?? 0),