clauderipple 0.9.2 → 0.9.3

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.9.3 — 2026-10-14
+
+### Fixed
+
+- **Claude workers offer X-High.** Claude's effort ladder stopped at high and max, so X-High could
+  not be picked for Claude in the mod or the dashboard though GPT had it. Opus, Sonnet and Haiku 5.5
+  all take it (#56).
+- **A model ticked after the mod's worker list was saved is usable.** It used to stay off and show
+  as unavailable in the mod (GPT-6 Astra in #56). A worker the list has not seen now starts on.
+  Settings saved before this keep the old reading until the list is changed once.
+- **The plan limit shows in the band on Claude chats.** The desktop Code tab left the mod's rate
+  limits empty, so the limit never appeared even with it switched on. The mod now falls back to the
+  router's figure for the same Claude login, and hides it when that figure is over 15 minutes old.
+- `/ripple-bar` no longer says the band is shown above the prompt when the layout is Minimal, where
+  only the short line under the prompt is drawn (#56).
+- The close button lights as one disc under the pointer instead of drawing a second box around it.
+
 ## 0.9.2 — 2026-10-14
 
 ### Added

package/dist/app/package.json

@@ -1,5 +1,5 @@
 {
   "private": true,
-  "version": "0.9.2",
+  "version": "0.9.3",
   "type": "commonjs"
 }

package/dist/mod/hooks/i18n.ts

@@ -361,6 +361,7 @@ const EN = {
   'commands.logOpened': 'ClaudeRipple log opened.',
   'commands.logClosed': 'ClaudeRipple log closed.',
   'commands.barShown': 'ClaudeRipple line shown above the prompt.',
+  'commands.barShownMinimal': 'The layout is Minimal, so ClaudeRipple shows as a short line under the prompt. For the full band above the prompt, set Layout to Dashboard in /ripple settings.',
   'commands.barHidden': 'ClaudeRipple line hidden. /ripple-bar shows it again.',
   'commands.statsAuto': 'Auto: {prompts} prompts, {requests} requests; {total} weighted tokens',
   'commands.statsTokens': 'Tokens: input {input}, write {write}, read {read}, output {output}',
@@ -810,6 +811,7 @@ const KO: Record<Key, string> = {
   'commands.logOpened': 'ClaudeRipple 로그를 열었습니다.',
   'commands.logClosed': 'ClaudeRipple 로그를 닫았습니다.',
   'commands.barShown': '프롬프트 상단에 ClaudeRipple 상태 바를 표시합니다.',
+  'commands.barShownMinimal': '레이아웃이 최소화로 되어 있어 ClaudeRipple은 프롬프트 아래 한 줄로만 표시됩니다. 프롬프트 위에 상태 바를 띄우려면 /ripple settings에서 레이아웃을 대시보드로 바꾸십시오.',
   'commands.barHidden': 'ClaudeRipple 상태 바를 숨겼습니다. /ripple-bar로 다시 표시할 수 있습니다.',
   'commands.statsAuto': '자동: 프롬프트 {prompts}개, 요청 {requests}개, 가중 토큰 {total}',
   'commands.statsTokens': '토큰: 입력 {input}, 쓰기 {write}, 읽기 {read}, 출력 {output}',
@@ -1257,6 +1259,7 @@ const ZH: Record<Key, string> = {
   'commands.logOpened': '已打开 ClaudeRipple 日志。',
   'commands.logClosed': '已关闭 ClaudeRipple 日志。',
   'commands.barShown': 'ClaudeRipple 状态栏已显示在提示词上方。',
+  'commands.barShownMinimal': '布局是“极简”，所以 ClaudeRipple 只在提示词下方显示一行。要在提示词上方显示完整状态栏，请在 /ripple settings 里把布局改为“仪表盘”。',
   'commands.barHidden': 'ClaudeRipple 状态栏已隐藏，/ripple-bar 可重新显示。',
   'commands.statsAuto': '自动：{prompts} 条提示词，{requests} 次请求；加权 token {total}',
   'commands.statsTokens': 'Token：输入 {input}，写入 {write}，读取 {read}，输出 {output}',
@@ -1704,6 +1707,7 @@ const JA: Record<Key, string> = {
   'commands.logOpened': 'ClaudeRipple のログを開きました。',
   'commands.logClosed': 'ClaudeRipple のログを閉じました。',
   'commands.barShown': 'ClaudeRipple のバーをプロンプトの上に表示しました。',
+  'commands.barShownMinimal': 'レイアウトがミニマルなので、ClaudeRipple はプロンプトの下に 1 行で表示されます。プロンプトの上にバーを出すには、/ripple settings でレイアウトをダッシュボードにしてください。',
   'commands.barHidden': 'ClaudeRipple のバーを非表示にしました。/ripple-bar で再表示できます。',
   'commands.statsAuto': '自動: プロンプト {prompts} 件、リクエスト {requests} 件、加重トークン {total}',
   'commands.statsTokens': 'トークン: 入力 {input}、書き込み {write}、読み取り {read}、出力 {output}',
@@ -2151,6 +2155,7 @@ const ES: Record<Key, string> = {
   'commands.logOpened': 'Registro de ClaudeRipple abierto.',
   'commands.logClosed': 'Registro de ClaudeRipple cerrado.',
   'commands.barShown': 'Barra de ClaudeRipple visible sobre el prompt.',
+  'commands.barShownMinimal': 'La disposición es Mínimo, así que ClaudeRipple aparece como una línea corta bajo el prompt. Para la barra completa sobre el prompt, elige Panel en Disposición en /ripple settings.',
   'commands.barHidden': 'Barra de ClaudeRipple oculta. /ripple-bar la vuelve a mostrar.',
   'commands.statsAuto': 'Auto: {prompts} prompts, {requests} solicitudes; {total} tokens ponderados',
   'commands.statsTokens': 'Tokens: entrada {input}, escritura {write}, lectura {read}, salida {output}',
@@ -2598,6 +2603,7 @@ const PT: Record<Key, string> = {
   'commands.logOpened': 'Log do ClaudeRipple aberto.',
   'commands.logClosed': 'Log do ClaudeRipple fechado.',
   'commands.barShown': 'Barra do ClaudeRipple visível acima do prompt.',
+  'commands.barShownMinimal': 'O layout está em Mínimo, então o ClaudeRipple aparece como uma linha curta abaixo do prompt. Para a barra completa acima do prompt, escolha Painel em Layout no /ripple settings.',
   'commands.barHidden': 'Barra do ClaudeRipple oculta. /ripple-bar mostra de novo.',
   'commands.statsAuto': 'Auto: {prompts} prompts, {requests} requisições; {total} tokens ponderados',
   'commands.statsTokens': 'Tokens: entrada {input}, gravação {write}, leitura {read}, saída {output}',

package/dist/mod/hooks/ladder.js

@@ -150,9 +150,9 @@ export function preset(id, choices) {
     }
     return { rungs, substituted };
 }
-/** The choices a person ticked; an empty list ticks every one. */
-export function tickedChoices(choices, allow) {
-    return choices.filter(choice => isAllowed(candidateKey(choice.target), choice.provider, allow));
+/** The choices a person ticked; an empty list ticks every one, and a key absent from `known` ticks on too. */
+export function tickedChoices(choices, allow, known = []) {
+    return choices.filter(choice => isAllowed(candidateKey(choice.target), choice.provider, allow, known));
 }
 /** Only empty lists need filling; unticked entries stay in order and are skipped at dispatch. */
 export function ladderNeedsFill(rungs, _allow = []) {
@@ -162,8 +162,8 @@ export function ladderNeedsFill(rungs, _allow = []) {
  * Fill empty lists from the ticked, connected choices. Existing ordered lists are never rewritten
  * for temporary availability or shared allow-list changes; dispatch explains each skipped entry.
  */
-export function fillLadder(rungs, allow, choices) {
-    const pick = preset('claudeGpt', tickedChoices(choices, allow));
+export function fillLadder(rungs, allow, choices, known = []) {
+    const pick = preset('claudeGpt', tickedChoices(choices, allow, known));
     const out = {};
     const filled = [];
     for (const rung of RUNGS) {

package/dist/mod/hooks/ladder.ts

@@ -146,9 +146,9 @@ export function preset(id: PresetId, choices: readonly LadderChoice[]): Preset {
   return { rungs, substituted }
 }
 
-/** The choices a person ticked; an empty list ticks every one. */
-export function tickedChoices(choices: readonly LadderChoice[], allow: readonly string[]): LadderChoice[] {
-  return choices.filter(choice => isAllowed(candidateKey(choice.target), choice.provider, allow))
+/** The choices a person ticked; an empty list ticks every one, and a key absent from `known` ticks on too. */
+export function tickedChoices(choices: readonly LadderChoice[], allow: readonly string[], known: readonly string[] = []): LadderChoice[] {
+  return choices.filter(choice => isAllowed(candidateKey(choice.target), choice.provider, allow, known))
 }
 
 /** Only empty lists need filling; unticked entries stay in order and are skipped at dispatch. */
@@ -160,8 +160,8 @@ export function ladderNeedsFill(rungs: Rungs, _allow: readonly string[] = []): b
  * Fill empty lists from the ticked, connected choices. Existing ordered lists are never rewritten
  * for temporary availability or shared allow-list changes; dispatch explains each skipped entry.
  */
-export function fillLadder(rungs: Rungs, allow: readonly string[], choices: readonly LadderChoice[]): { rungs: Record<Rung, Step[]>; filled: Rung[] } {
-  const pick = preset('claudeGpt', tickedChoices(choices, allow))
+export function fillLadder(rungs: Rungs, allow: readonly string[], choices: readonly LadderChoice[], known: readonly string[] = []): { rungs: Record<Rung, Step[]>; filled: Rung[] } {
+  const pick = preset('claudeGpt', tickedChoices(choices, allow, known))
   const out = {} as Record<Rung, Step[]>
   const filled: Rung[] = []
   for (const rung of RUNGS) {

package/dist/mod/hooks/register.tsx

@@ -1,7 +1,7 @@
 // Engine wiring lives here: imported logic and drawings never receive the engine interface.
 // Timers own background work; hooks only admit/rewrite a request and record its result.
 import { atom, read, update } from 'claude-code'
-import type { AgentSpawnInput, EngineInterface, ModelCompleteResult, ModelForkResult, Register, RenderElement, RenderInput, ToolCallInput, TurnStepInput, TurnUsage } from 'claude-code'
+import type { AgentSpawnInput, EngineInterface, ModelCompleteResult, ModelForkResult, Register, RenderElement, RenderInput, SessionRateLimit, ToolCallInput, TurnStepInput, TurnUsage } from 'claude-code'
 import type { AgentRec, Effort, JudgeInput, JudgeKind, JudgeRun, ModSettingsSnapshot, Pick, Settings, StatusRequest, TierTarget, Verdict, WorkerCandidate, WorkerPick, WorkerVerdict } from '../types'
 import { MOD_SETTINGS_SCHEMA_VERSION, applySettingsChanges, normalizeSettings, settingsChanges } from './settings'
 import { debugText, langFrom, t } from './i18n'
@@ -13,7 +13,7 @@ import { activeModeOf, claudeWindow, eagerNote, modeKey, modeOver, quotaWindows,
 import type { QuotaWindow } from './modes'
 import type { Spawn, WorkerFix } from './worker'
 import { afterPing, nextMemo, restoreFromResume, shouldPing } from './cache'
-import { bandPriority, coldAlert, hotAlert, hottest, keptAlert, saveUntil as limitSaveUntil, swampAlert, swamped } from './session'
+import { bandPriority, claudeLimitsFrom, coldAlert, hotAlert, hottest, keptAlert, saveUntil as limitSaveUntil, swampAlert, swamped } from './session'
 import { COMPACT_SYSTEM, compactResult, serializeTranscript } from './compact'
 import { ADVICE_SYSTEM, FULL_PROMPT, QUICK_PROMPT, adviceDue, adviceInput, parseAdvice, wrapForNewChat } from './handoff'
 import { addJudge, addPrompt, addRequest, addWarm, addWorker, emptyStats, formatStats, weighted } from './stats'
@@ -442,7 +442,7 @@ async function refreshLadder($: EngineInterface): Promise<void> {
   try {
     const response = await $.http.fetch(`${await adminUrl($)}/api/mod-options`)
     if (!response.ok) throw new Error(t(await read($, lang), 'commands.routerHttp', { status: response.status }))
-    const fresh = ladderOptionsFrom(JSON.parse(response.text), await $.clock.now() + KEEP_MS, (await currentSettings($)).allow)
+    const fresh = ladderOptionsFrom(JSON.parse(response.text), await $.clock.now() + KEEP_MS, (await currentSettings($)).allow, (await currentSettings($)).allowKnown)
     if (!same(await read($, ladderOptions), fresh)) await update($, ladderOptions, () => fresh)
   } catch (error) { await report($, 'ladder options', error) }
 }
@@ -692,7 +692,7 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   const routing = routingSettings(s)
   const resolved = explicitCandidate && candidateUsable(explicitCandidate, s, usable, providers)
     ? { target: target!, effort: verdict.effort }
-    : ladderPick(verdict, routing.rules.general, routing, pinnedCandidates, usable, language, routing.allow, providers)
+    : ladderPick(verdict, routing.rules.general, routing, pinnedCandidates, usable, language, routing.allow, providers, routing.allowKnown)
   const selected = resolved.target
   if (!selected) return { deny: t(language, 'workers.none') }
   const fallbackReason = resolved.fallbackReason
@@ -931,6 +931,13 @@ async function openCompact($: EngineInterface, surface: Frame['surface']): Promi
   await update($, compactNote, () => '')
   await update($, panel, () => 'compact')
 }
+/** The router's figure for this login's plan windows; nothing when the router cannot say. */
+async function routerClaudeLimits($: EngineInterface): Promise<SessionRateLimit[]> {
+  try {
+    const status = await $.http.fetch(`${await adminUrl($)}/api/status`)
+    return status.ok ? claudeLimitsFrom(JSON.parse(status.text), await $.clock.now()) : []
+  } catch (error) { await report($, 'claude limits', error); return [] }
+}
 async function refreshUsage($: EngineInterface): Promise<void> {
   const usage = await $.session.usage()
   const c = usage.context
@@ -940,11 +947,15 @@ async function refreshUsage($: EngineInterface): Promise<void> {
   // Below the line again (a compact, a clear), the next crossing shows the heavy-context band once.
   const putOff = await read($, swampHidden)
   if (putOff !== null && (putOff > 100 || !ctx || ctx.percent < (await currentSettings($)).swampAt)) await update($, swampHidden, () => null)
-  const h = hottest(usage.rateLimits)
+  // The host can leave the plan windows out though the replies carried them; on a Claude chat the
+  // router's figure for the same login stands in.
+  const own = usage.rateLimits.some(l => ['five_hour', 'seven_day'].includes(l.kind))
+  const rateLimits = own || !/^claude-/.test(await $.session.model()) ? usage.rateLimits : [...usage.rateLimits, ...await routerClaudeLimits($)]
+  const h = hottest(rateLimits)
   const previous = await read($, hot)
   if (previous && (!h || previous.kind !== h.kind || previous.resetsAt !== h.resetsAt)) await update($, hotHidden, () => null)
   if (JSON.stringify(h) !== JSON.stringify(previous)) await update($, hot, () => h)
-  const top = usage.rateLimits.filter(l => ['five_hour', 'seven_day'].includes(l.kind)).sort((a, b) => b.percentUsed - a.percentUsed)[0]
+  const top = rateLimits.filter(l => ['five_hour', 'seven_day'].includes(l.kind)).sort((a, b) => b.percentUsed - a.percentUsed)[0]
   const l = top ? { kind: top.kind, percent: top.percentUsed, ...(top.resetsAt ? { resetsAt: top.resetsAt } : {}) } : null
   // Check the previous binding deadline before a rolled-forward snapshot replaces it.
   await endModeIfOver($)
@@ -1469,7 +1480,9 @@ export const register: Register = on => {
   on('command.run', { command: 'ripple-bar' }, async ($, e, next) => {
     try {
       const language = await read($, lang)
-      return { text: await toggleBar($) ? t(language, 'commands.barShown') : t(language, 'commands.barHidden') } }
+      if (!await toggleBar($)) return { text: t(language, 'commands.barHidden') }
+      // The minimal layout draws no band above the prompt, only the short line under it (#56).
+      return { text: t(language, (await currentSettings($)).layout === 'minimal' ? 'commands.barShownMinimal' : 'commands.barShown') } }
     catch (error) { await report($, 'ripple-bar', error); return next(e) }
   })
   on('ui.close', { id: LOG_PANE }, async ($, e, next) => {

package/dist/mod/hooks/session.ts

@@ -7,6 +7,32 @@ export function hottest(rateLimits: readonly SessionRateLimit[]): Hot | null {
   return limit ? { kind: limit.kind, percent: limit.percentUsed, ...(limit.resetsAt ? { resetsAt: limit.resetsAt } : {}) } : null
 }
 
+const WINDOW_KIND: Record<number, string> = { 300: 'five_hour', 10080: 'seven_day' }
+/** A router snapshot older than this is not shown as the plan's figure. */
+export const CLAUDE_USAGE_STALE_MS = 15 * 60_000
+
+/**
+ * The plan windows of the Claude login this session's requests pass through, from the router's
+ * GET /api/status (`claude.accounts[id=current].quota`, packages/router/src/admin.ts
+ * claudeAccountUsage): for when the host leaves `rateLimits` empty though the requests carry them
+ * (measured 2026-10-14: the router passes the `anthropic-ratelimit-unified-*` headers through).
+ * Percent as the router reports it; a stale or unknown snapshot gives nothing.
+ */
+export function claudeLimitsFrom(status: unknown, now: number): SessionRateLimit[] {
+  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 limits = object(quota.rate_limits)
+  return [limits.primary, limits.secondary].map(object).flatMap(w => {
+    const kind = typeof w.window_minutes === 'number' ? WINDOW_KIND[w.window_minutes] : undefined
+    if (!kind || typeof w.used_percent !== 'number' || !Number.isFinite(w.used_percent)) return []
+    const reset = typeof w.reset_at === 'number' ? w.reset_at * (w.reset_at < 1e12 ? 1000 : 1) : NaN
+    return [{ kind, percentUsed: Math.round(w.used_percent * 10) / 10, ...(Number.isFinite(reset) ? { resetsAt: new Date(reset).toISOString() } : {}) }]
+  })
+}
+
 /**
  * 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.

package/dist/mod/hooks/settings.js

@@ -21,7 +21,7 @@ export const DEFAULTS = {
                 hard: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], plan: [claude('opus', 'high')],
             } },
     },
-    allow: [], modes: [],
+    allow: [], allowKnown: [], modes: [],
     providers: {},
     fallback: { agent: 'general-purpose', model: 'sonnet' },
     keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
@@ -158,16 +158,16 @@ export function migrateAllow(allow, workers) {
     const agents = new Set(workers.map(w => w.name));
     return [...new Set(allow.flatMap(entry => agents.has(entry) || !workers.some(w => w.provider === entry) ? [entry] : workers.filter(w => w.provider === entry).map(w => w.name)))];
 }
-/** The workers switched on by an allow-list; empty means every worker. */
-export function allowedWorkers(allow, workers) {
+/** The workers switched on by an allow-list; empty means every worker. A worker that did not exist when the list was last written (absent from `known`) counts as on. */
+export function allowedWorkers(allow, workers, known = []) {
     if (!allow.length)
         return workers.map(w => w.name);
     const on = new Set(migrateAllow(allow, workers));
-    return workers.filter(w => on.has(w.name)).map(w => w.name);
+    return workers.filter(w => on.has(w.name) || known.length > 0 && !known.includes(w.name)).map(w => w.name);
 }
-/** Switches one worker; every worker on again is stored as [], and the last one cannot go off. */
-export function toggleAllow(allow, name, workers) {
-    const on = allowedWorkers(allow, workers);
+/** Switches one worker; every worker on again is stored as [], and the last one cannot go off. `known` is the allow-list keys the writer knew. */
+export function toggleAllow(allow, name, workers, known = []) {
+    const on = allowedWorkers(allow, workers, known);
     const next = on.includes(name) ? on.filter(n => n !== name) : workers.filter(w => w.name === name || on.includes(w.name)).map(w => w.name);
     if (!next.length)
         return [...allow];
@@ -175,10 +175,11 @@ export function toggleAllow(allow, name, workers) {
 }
 /**
  * Whether a stored model is ticked: its key (an agent name, or `general-purpose:<model>`) or, for
- * settings from before 2026-10-10, its provider is listed; an empty list ticks every model.
+ * settings from before 2026-10-10, its provider is listed; an empty list ticks every model. A key
+ * absent from a non-empty `known` list (a worker added after the list was last written) ticks on.
  */
-export function isAllowed(key, provider, allow) {
-    return !allow.length || allow.includes(key) || allow.includes(provider);
+export function isAllowed(key, provider, allow, known = []) {
+    return !allow.length || allow.includes(key) || allow.includes(provider) || known.length > 0 && !known.includes(key);
 }
 /** The design ladder every save stored until 2026-10-12: Claude, Sonnet then Opus. */
 const RETIRED_DESIGN = JSON.stringify([claude('sonnet', 'medium'), claude('sonnet', 'high'), claude('opus', 'high'), claude('opus', 'high')].map(s => [s.target.agent, s.target.model, s.effort]));
@@ -266,7 +267,8 @@ export function normalizeSettings(raw, workers) {
         rules.general = ladderFromPin(targets, {});
     }
     const ticked = names(Array.isArray(value.allow) ? value.allow : object(stored.general).mode === 'auto' ? object(stored.general).allow : []);
-    const result = { ...DEFAULTS, rules, allow: workers?.length ? migrateAllow(ticked, workers) : ticked, providers: {}, hide: [...DEFAULTS.hide], extras: [...DEFAULTS.extras], fallback: { ...DEFAULTS.fallback } };
+    const savedKnown = names(value.allowKnown);
+    const result = { ...DEFAULTS, rules, allow: workers?.length ? migrateAllow(ticked, workers) : ticked, allowKnown: savedKnown, providers: {}, hide: [...DEFAULTS.hide], extras: [...DEFAULTS.extras], fallback: { ...DEFAULTS.fallback } };
     for (const [name, enabled] of Object.entries(object(value.providers)))
         if (typeof enabled === 'boolean')
             result.providers[name] = enabled;

package/dist/mod/hooks/settings.ts

@@ -26,7 +26,7 @@ export const DEFAULTS: Settings = {
       hard: [{ target: { agent: 'gpt-6-astra' }, effort: 'high' }], plan: [claude('opus', 'high')],
     } },
   },
-  allow: [], modes: [],
+  allow: [], allowKnown: [], modes: [],
   providers: {},
   fallback: { agent: 'general-purpose', model: 'sonnet' },
   keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
@@ -159,16 +159,16 @@ export function migrateAllow(allow: readonly string[], workers: readonly Worker[
   return [...new Set(allow.flatMap(entry => agents.has(entry) || !workers.some(w => w.provider === entry) ? [entry] : workers.filter(w => w.provider === entry).map(w => w.name)))]
 }
 
-/** The workers switched on by an allow-list; empty means every worker. */
-export function allowedWorkers(allow: readonly string[], workers: readonly Worker[]): string[] {
+/** The workers switched on by an allow-list; empty means every worker. A worker that did not exist when the list was last written (absent from `known`) counts as on. */
+export function allowedWorkers(allow: readonly string[], workers: readonly Worker[], known: readonly string[] = []): string[] {
   if (!allow.length) return workers.map(w => w.name)
   const on = new Set(migrateAllow(allow, workers))
-  return workers.filter(w => on.has(w.name)).map(w => w.name)
+  return workers.filter(w => on.has(w.name) || known.length > 0 && !known.includes(w.name)).map(w => w.name)
 }
 
-/** Switches one worker; every worker on again is stored as [], and the last one cannot go off. */
-export function toggleAllow(allow: readonly string[], name: string, workers: readonly Worker[]): string[] {
-  const on = allowedWorkers(allow, workers)
+/** Switches one worker; every worker on again is stored as [], and the last one cannot go off. `known` is the allow-list keys the writer knew. */
+export function toggleAllow(allow: readonly string[], name: string, workers: readonly Worker[], known: readonly string[] = []): string[] {
+  const on = allowedWorkers(allow, workers, known)
   const next = on.includes(name) ? on.filter(n => n !== name) : workers.filter(w => w.name === name || on.includes(w.name)).map(w => w.name)
   if (!next.length) return [...allow]
   return next.length === workers.length ? [] : next
@@ -176,10 +176,11 @@ export function toggleAllow(allow: readonly string[], name: string, workers: rea
 
 /**
  * Whether a stored model is ticked: its key (an agent name, or `general-purpose:<model>`) or, for
- * settings from before 2026-10-10, its provider is listed; an empty list ticks every model.
+ * settings from before 2026-10-10, its provider is listed; an empty list ticks every model. A key
+ * absent from a non-empty `known` list (a worker added after the list was last written) ticks on.
  */
-export function isAllowed(key: string, provider: string, allow: readonly string[]): boolean {
-  return !allow.length || allow.includes(key) || allow.includes(provider)
+export function isAllowed(key: string, provider: string, allow: readonly string[], known: readonly string[] = []): boolean {
+  return !allow.length || allow.includes(key) || allow.includes(provider) || known.length > 0 && !known.includes(key)
 }
 
 /** The design ladder every save stored until 2026-10-12: Claude, Sonnet then Opus. */
@@ -262,7 +263,8 @@ export function normalizeSettings(raw: unknown, workers?: readonly Worker[]): Se
     rules.general = ladderFromPin(targets, {})
   }
   const ticked = names(Array.isArray(value.allow) ? value.allow : object(stored.general).mode === 'auto' ? object(stored.general).allow : [])
-  const result: Settings = { ...DEFAULTS, rules, allow: workers?.length ? migrateAllow(ticked, workers) : ticked, providers: {}, hide: [...DEFAULTS.hide], extras: [...DEFAULTS.extras], fallback: { ...DEFAULTS.fallback } }
+  const savedKnown = names(value.allowKnown)
+  const result: Settings = { ...DEFAULTS, rules, allow: workers?.length ? migrateAllow(ticked, workers) : ticked, allowKnown: savedKnown, providers: {}, hide: [...DEFAULTS.hide], extras: [...DEFAULTS.extras], fallback: { ...DEFAULTS.fallback } }
   for (const [name, enabled] of Object.entries(object(value.providers))) if (typeof enabled === 'boolean') result.providers[name] = enabled
   for (const key of ['effortAuto', 'keepWarm', 'setupDone', 'swampAlert'] as const) if (typeof value[key] === 'boolean') result[key] = value[key]
   if (Array.isArray(value.extras)) result.extras = [...new Set(value.extras.filter((part): part is string => typeof part === 'string' && EXTRAS.includes(part)))]

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

@@ -431,8 +431,8 @@ export function wellArt(width: number, height: number): string {
 export const CLOSE_PX = 22
 
 /** The way out of a capsule, 22 px: a soft disc with a ×. */
-export function closeArt(): string {
-  return svg(CLOSE_PX, CLOSE_PX, '<circle cx="11" cy="11" r="10" fill="#fff" fill-opacity=".07" stroke="' + HAIR + '" stroke-opacity=".2"/><path d="M7.6 7.6l6.8 6.8M14.4 7.6l-6.8 6.8" stroke="' + LABEL + '" stroke-width="1.6" stroke-linecap="round"/>')
+export function closeArt(lit = false): string {
+  return svg(CLOSE_PX, CLOSE_PX, '<circle cx="11" cy="11" r="10" fill="#fff" fill-opacity="' + (lit ? '.16' : '.07') + '" stroke="' + HAIR + '" stroke-opacity="' + (lit ? '.45' : '.2') + '"/><path d="M7.6 7.6l6.8 6.8M14.4 7.6l-6.8 6.8" stroke="' + LABEL + '" stroke-width="1.6" stroke-linecap="round"/>')
 }
 
 // ---- The band's instruments ---------------------------------------------------------------------

package/dist/mod/hooks/ui/kit.tsx

@@ -161,9 +161,22 @@ export function pill(el: Els, key: string, label: string, look: PillLook, onPres
 /** Cells the way out takes. */
 export const CLOSE_CELLS = cellsOf(CLOSE_PX + 4)
 
-/** The way out: a soft disc with a ×, `label` its name for a reader that cannot see it. */
+/**
+ * The way out: a soft disc with a ×, `label` its name for a reader that cannot see it. The disc is
+ * its own light under the pointer: `lit`'s rounded box around it read as a second button
+ * (2026-10-14).
+ */
 export function closeButton(el: Els, key: string, label: string, onPress: () => void, scope?: string): RenderNode {
-  return lit(el, key, CLOSE_CELLS, [pic(el, key, closeArt(), label, CLOSE_PX, CLOSE_PX), press(el, key, CLOSE_CELLS * CELL_PX, onPress)], 0.25, scope)
+  const { Box } = el
+  return (
+    <Box key={'hv-' + key} position="relative" flexDirection="row" alignItems="center" justifyContent="center" width={CLOSE_CELLS} flexShrink={0} {...(scope ? { hover: { scope } } : {})}>
+      {pic(el, key, closeArt(), label, CLOSE_PX, CLOSE_PX)}
+      <Box position="absolute" top={0} bottom={0} left={0} right={0} alignItems="center" justifyContent="center" display="none" hover={{ display: 'flex' }}>
+        {pic(el, key + '-lit', closeArt(true), label, CLOSE_PX, CLOSE_PX)}
+      </Box>
+      {press(el, key, CLOSE_CELLS * CELL_PX, onPress)}
+    </Box>
+  )
 }
 
 /** Cells a switch and its word take, their hover's air included. */

package/dist/mod/hooks/workers.ts

@@ -93,8 +93,8 @@ export function scoreModels(raw: unknown): ModelScore[] {
  * Allow-lists name worker agents, and Claude's own models as `general-purpose:<model>`; provider
  * names from settings saved before 2026-10-10 still match.
  */
-export function allowed(candidate: WorkerCandidate, allow: readonly string[]): boolean {
-  return isAllowed(candidateKey(candidate.target), candidate.provider, allow)
+export function allowed(candidate: WorkerCandidate, allow: readonly string[], known: readonly string[] = []): boolean {
+  return isAllowed(candidateKey(candidate.target), candidate.provider, allow, known)
 }
 /** Claude's own models as candidates: general-purpose on each. */
 export function claudeCandidates(): WorkerCandidate[] {
@@ -106,16 +106,16 @@ const BILLINGS: readonly Billing[] = ['free', 'payg', 'subscription']
  * provider can run now, with ladders, billing and cheapest measured cost, then Claude's own
  * models; only the ticked ones (`allow`, empty for every model).
  */
-export function ladderOptionsFrom(raw: unknown, until: number, allow: readonly string[] = []): LadderOptions {
+export function ladderOptionsFrom(raw: unknown, until: number, allow: readonly string[] = [], allowKnown: readonly string[] = []): LadderOptions {
   const root = record(raw)
   const efforts = (value: unknown): Effort[] => list(value).filter((e): e is Effort => EFFORTS.includes(e as Effort))
   const usable = new Set(list(root.providers).flatMap(p => { const v = record(p); return typeof v.name === 'string' && v.usable !== false ? [v.name] : [] }))
-  const known = list(root.providers).length > 0
+  const catalogue = list(root.providers).length > 0
   const scores = scoreModels(root.scores)
   const choices: LadderChoice[] = list(root.agents).flatMap(value => {
     const a = record(value)
     if (typeof a.name !== 'string' || !a.name || typeof a.model !== 'string' || typeof a.provider !== 'string') return []
-    if (known && !usable.has(a.provider)) return []
+    if (catalogue && !usable.has(a.provider)) return []
     const costs = (scores.find(s => s.model === a.model && s.provider === a.provider)?.variants ?? []).flatMap(v => v.costPerTask === null ? [] : [v.costPerTask])
     const billing = BILLINGS.includes(a.billing as Billing) ? a.billing as Billing : 'payg'
     return [{ target: { agent: a.name }, model: a.model, provider: a.provider, billing, efforts: efforts(a.efforts), ...(costs.length ? { cost: Math.min(...costs) } : {}) }]
@@ -125,7 +125,7 @@ export function ladderOptionsFrom(raw: unknown, until: number, allow: readonly s
     if (typeof p.name !== 'string' || typeof p.usable !== 'boolean') return []
     return [[p.name, { usable: p.usable, ...(typeof p.reason === 'string' ? { reason: p.reason } : {}), ...(typeof p.exhaustedUntil === 'number' ? { exhaustedUntil: p.exhaustedUntil } : {}) }]]
   }))
-  return { until, choices: tickedChoices([...choices, ...claudeChoices(efforts(root.claudeEfforts))], allow), providers }
+  return { until, choices: tickedChoices([...choices, ...claudeChoices(efforts(root.claudeEfforts))], allow, allowKnown), providers }
 }
 export function candidateUsable(candidate: WorkerCandidate, settings: Settings, chatgpt: boolean, providers: NonNullable<LadderOptions['providers']> = {}): boolean {
   const live = providers[candidate.provider]
@@ -152,7 +152,7 @@ export const SESSION_MODEL: TierTarget = { agent: 'general-purpose' }
  * The ladder: the verdict's rung, else one rung up, else the session model, never down. Whatever
  * ran instead says why (the fallback toast).
  */
-export function ladderPick(verdict: WorkerVerdict, rule: Rule, settings: Settings, candidates: readonly WorkerCandidate[], chatgpt: boolean, lang: Lang, allow: readonly string[] = [], providers: NonNullable<LadderOptions['providers']> = {}): Resolution {
+export function ladderPick(verdict: WorkerVerdict, rule: Rule, settings: Settings, candidates: readonly WorkerCandidate[], chatgpt: boolean, lang: Lang, allow: readonly string[] = [], providers: NonNullable<LadderOptions['providers']> = {}, known: readonly string[] = []): Resolution {
   const wanted = rungOf(verdict)
   const skipped: NonNullable<Resolution['skipped']> = []
   const reasons: string[] = []
@@ -163,7 +163,7 @@ export function ladderPick(verdict: WorkerVerdict, rule: Rule, settings: Setting
     for (const [index, step] of steps.entries()) {
       const target = step.target
       const candidate = candidateOf(target, candidates)
-      const ticked = target.agent === 'general-purpose' && !target.model || candidate && allowed(candidate, allow)
+      const ticked = target.agent === 'general-purpose' && !target.model || candidate && allowed(candidate, allow, known)
       if (candidate && candidateUsable(candidate, settings, chatgpt, providers) && ticked) {
         return { target: { ...target }, effort: step.effort, rung, position: index + 1, skipped, ...(reasons.length ? { fallbackReason: reasons.join('; ') } : {}) }
       }

package/dist/mod/tests/register.test.tsx

@@ -1184,6 +1184,16 @@ for (const surface of ['terminal', 'desktop'] as const) test('quick controls sav
   await ui.unmount()
 })
 
+test('ripple-bar says where the line is when the layout is minimal', async ($, on) => {
+  const b = boundaries(on, { layout: 'minimal' })
+  http(on)
+  await start($)
+  const run = () => $.command.run({ command: 'ripple-bar', origin: { kind: 'composer' }, presentation: { isFullscreen: true, columns: 140 }, args: '' })
+  expect((await run()).text).toContain('hidden')
+  expect(b.saved.get('bandHidden')).toBe(true)
+  expect((await run()).text).toContain('Minimal')
+})
+
 for (const surface of ['terminal', 'desktop'] as const) test('quick settings select a saved mode, never edit rungs, on ' + surface, async ($, on) => {
   const b = boundaries(on, { modes: BURN })
   http(on)

package/dist/mod/types/index.d.ts

@@ -149,6 +149,12 @@ export type Settings = {
    * picks, only among these.
    */
   allow: string[]
+  /**
+   * The allow-list keys of every worker that existed when `allow` was last written (what
+   * `candidateKey` returns). A key absent from this non-empty list counts as ticked on; empty means
+   * either every worker is ticked (`allow` empty) or all writers predate the field (#56).
+   */
+  allowKnown: string[]
   /** The user's operating modes; none is built in. */
   modes: Mode[]
   /** The mode that is on, by id; absent when none is. */

package/dist/router/src/admin.js

@@ -100,7 +100,8 @@ async function claudeAccountUsage(deps) {
     }
     return rows;
 }
-const ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high", "max"];
+// The CLI's `--effort` takes the same five; Opus, Sonnet and Haiku 5.5 answered `xhigh` (requests.jsonl, 2026-10-14, #56).
+const ANTHROPIC_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 const CHATGPT_DEFAULT_EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 let chatgptLogin = { running: false };
 /** The Claude subscription sign-in in progress (or the last one), for GET /api/claude-oauth. */
@@ -411,8 +412,8 @@ async function withFilledLadder(deps, scores, settings) {
         return settings;
     try {
         const choices = ladderChoices(await modOptions(deps, scores));
-        const { rungs } = fillLadder(general.rungs, settings.allow, choices);
-        const modes = settings.modes.map(mode => ({ ...mode, rungs: fillLadder(mode.rungs, settings.allow, choices).rungs }));
+        const { rungs } = fillLadder(general.rungs, settings.allow, choices, settings.allowKnown);
+        const modes = settings.modes.map(mode => ({ ...mode, rungs: fillLadder(mode.rungs, settings.allow, choices, settings.allowKnown).rungs }));
         return { ...settings, rules: { general: { mode: "ladder", rungs } }, modes };
     }
     catch (error) {

package/dist/router/src/version.js

@@ -5,4 +5,4 @@
 // from the manifests. Until 0.1.1 the router and the CLI each carried their own literal, and both
 // still said "0.1.0" in the 0.1.1 release: after an update nobody could tell which router was
 // running, and the tray app had nothing to compare (2026-09-15, reported from a Windows install).
-export const VERSION = "0.9.2";
+export const VERSION = "0.9.3";

package/dist/ui/app.js

@@ -2486,7 +2486,7 @@ const MOD_DEFAULTS = {
       hard: [{ target: { agent: "gpt-6-astra" }, effort: "high" }], plan: [modClaude("opus", "high")],
     } },
   },
-  allow: [], modes: [], providers: {},
+  allow: [], allowKnown: [], modes: [], providers: {},
   fallback: { agent: "general-purpose", model: "sonnet" },
   keepWarm: false, keepWarmHours: 2, keepWarmMinTokens: 30000,
   compactWith: "haiku", handoffSkill: "", handoffAfter: "continue", handoffButton: "advised",
@@ -2510,6 +2510,7 @@ function modNormalize(raw) {
     ...value,
     rules: { ...clone(MOD_DEFAULTS.rules), ...(value.rules || {}) },
     allow: Array.isArray(value.allow) ? value.allow : [],
+    allowKnown: Array.isArray(value.allowKnown) ? value.allowKnown : [],
     modes: Array.isArray(value.modes) ? value.modes : [],
     providers: { ...(value.providers || {}) },
     hide: Array.isArray(value.hide) ? value.hide : clone(MOD_DEFAULTS.hide),
@@ -2695,7 +2696,7 @@ function modEffortCard() {
  */
 function modChoices() {
   const options = modState.options || {};
-  const claudeEfforts = Array.isArray(options.claudeEfforts) && options.claudeEfforts.length ? options.claudeEfforts : ["low", "medium", "high", "max"];
+  const claudeEfforts = Array.isArray(options.claudeEfforts) && options.claudeEfforts.length ? options.claudeEfforts : ["low", "medium", "high", "xhigh", "max"];
   const workers = modAgents().map((agent) => {
     const info = modProviderInfo(agent.provider);
     return {
@@ -2749,17 +2750,20 @@ function modGroupLabel(group) { return group.billing ? `${group.name} · ${t(`mo
 function modTickKey(choice) { return choice.claude ? choice.value.replace("+", ":") : choice.value; }
 /** The models that can be ticked: every worker and Claude's own; the session's model is always there. */
 function modTickable() { return modChoices().filter((choice) => choice.value !== "general-purpose"); }
-/** Whether a model is ticked: an empty list means every model, and an old provider name ticks that provider's. */
+/** Whether a model is ticked: an empty list means every model, an old provider name ticks that provider's, and a model added after the list was last written (absent from `allowKnown`) ticks on. */
 function modTicked(choice) {
   const allow = modState.settings.allow || [];
-  return !allow.length || allow.includes(modTickKey(choice)) || allow.includes(choice.provider);
+  const known = modState.settings.allowKnown || [];
+  return !allow.length || allow.includes(modTickKey(choice)) || allow.includes(choice.provider) || known.length > 0 && !known.includes(modTickKey(choice));
 }
 /** Ticks one model; every model on again is stored as [], and the last one on cannot go off. */
 function modTick(choice, on) {
   const all = modTickable();
-  const kept = new Set(all.filter(modTicked).map(modTickKey));
+  const known = all.map(modTickKey);
+  const kept = new Set(all.filter((model) => modTicked(model)).map(modTickKey));
   if (on) kept.add(modTickKey(choice)); else kept.delete(modTickKey(choice));
-  modPatch({ allow: kept.size === all.length ? [] : all.map(modTickKey).filter((key) => kept.has(key)) });
+  const allow = kept.size === known.length ? [] : known.filter((key) => kept.has(key));
+  modPatch({ allow, allowKnown: allow.length ? known : [] });
 }
 function modTickRows() {
   const choices = modTickable();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [