clauderipple 0.9.1 → 0.9.3

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, 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'
@@ -48,6 +48,7 @@ const lastSpawn = atom({ plugin: 'ripple', key: 'lastSpawn' } as const, null)
 const agents = atom({ plugin: 'ripple', key: 'agents' } as const, [])
 const cache = atom({ plugin: 'ripple', key: 'cache' } as const, null)
 const warm = atom({ plugin: 'ripple', key: 'warm' } as const, { pings: 0, cost: 0 })
+const warmHere = atom({ plugin: 'ripple', key: 'warmHere' } as const, null)
 const lastRealReplyAt = atom({ plugin: 'ripple', key: 'lastRealReplyAt' } as const, null)
 const context = atom({ plugin: 'ripple', key: 'context' } as const, null)
 const hot = atom({ plugin: 'ripple', key: 'hot' } as const, null)
@@ -56,6 +57,7 @@ const hotHidden = atom({ plugin: 'ripple', key: 'hotHidden' } as const, null)
 const saveUntil = atom({ plugin: 'ripple', key: 'saveUntil' } as const, null)
 const swampHidden = atom({ plugin: 'ripple', key: 'swampHidden' } as const, null)
 const coldHidden = atom({ plugin: 'ripple', key: 'coldHidden' } as const, false)
+const kept = atom({ plugin: 'ripple', key: 'kept' } as const, null)
 const judgeDown = atom({ plugin: 'ripple', key: 'judgeDown' } as const, null)
 const judgeDownHidden = atom({ plugin: 'ripple', key: 'judgeDownHidden' } as const, null)
 const judgeSeen = atom({ plugin: 'ripple', key: 'judgeSeen' } as const, [])
@@ -233,6 +235,8 @@ async function installSettings($: EngineInterface, s: Settings): Promise<void> {
   try { await registerAuto($, s) } catch (error) { await report($, 'agent register', error) }
   if (!s.effortAuto) await update($, heldPick, () => null)
   if (s.keepWarm && !previous.keepWarm) await update($, warm, value => ({ ...value, stopped: undefined }))
+  // Settings caught up with this chat's own choice: it follows Settings again.
+  if (await read($, warmHere) === s.keepWarm) await update($, warmHere, () => null)
 }
 function settingsSnapshot(text: string): ModSettingsSnapshot {
   const value = object(JSON.parse(text))
@@ -438,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) }
 }
@@ -688,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
@@ -712,9 +716,15 @@ async function toggleAuto($: EngineInterface): Promise<void> {
   const s = await currentSettings($)
   await saveSettings($, { ...s, effortAuto: !s.effortAuto })
 }
+/** The band's flame turns keep-warm on or off for this chat only; Settings is what a new chat starts with. */
+async function keepWarmOn($: EngineInterface, s: Settings): Promise<boolean> {
+  return await read($, warmHere) ?? s.keepWarm
+}
 async function toggleWarm($: EngineInterface): Promise<void> {
   const s = await currentSettings($)
-  await saveSettings($, { ...s, keepWarm: !s.keepWarm })
+  const on = !await keepWarmOn($, s)
+  await update($, warmHere, () => on === s.keepWarm ? null : on)
+  if (on) await update($, warm, value => ({ ...value, stopped: undefined }))
 }
 async function toggleSave($: EngineInterface): Promise<void> {
   const now = await $.clock.now()
@@ -921,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
@@ -930,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($)
@@ -986,7 +1007,8 @@ async function tick($: EngineInterface): Promise<void> {
       const answer = await $.model.complete({ model: HAIKU, system: ADVICE_SYSTEM, prompt: queued, effort: 'low', maxTokens: 60, timeoutMs: 8000 })
       if (answer.isAnswered) await update($, advice, () => parseAdvice(answer.text))
     }
-    const s = await currentSettings($)
+    const s = { ...await currentSettings($) }
+    s.keepWarm = await keepWarmOn($, s)
     const decision = shouldPing({ settings: s, memo: await read($, cache), warm: await read($, warm), now: await $.clock.now(), idle: !await read($, busy) && !await read($, deciding) && !forking,
       contextTokens: (await read($, context))?.tokens ?? 0, lastRealReplyAt: await read($, lastRealReplyAt) })
     if (decision.ping) {
@@ -997,6 +1019,15 @@ async function tick($: EngineInterface): Promise<void> {
       const after = afterPing(before, answer, await $.clock.now(), language)
       await update($, warm, () => after)
       if (after.stopped && !before.stopped) await $.ui.toast(t(language, 'toasts.warmStopped', { reason: after.stopped }))
+      // A ping read cache tokens: the cache held while the person was away. One card counts them all
+      // (a real reply or the expiry clears it; register.tsx kept), until then each ping adds up.
+      const usage = answer && 'usage' in answer ? answer.usage : null
+      if ((usage?.cache_read_input_tokens ?? 0) > 0) {
+        await update($, kept, prev => ({
+          pings: (prev?.pings ?? 0) + 1,
+          tokens: usage!.cache_read_input_tokens,
+        }))
+      }
     } else if (s.keepWarm && !await read($, busy) && decision.reason === 'keep warm time bound reached' && !(await read($, warm)).stopped) {
       await update($, warm, value => ({ ...value, stopped: t(language, 'toasts.warmBoundReason') }))
       await $.ui.toast(t(language, 'toasts.warmBound'))
@@ -1025,7 +1056,7 @@ async function dashboard($: EngineInterface, working: boolean): Promise<Dashboar
       mode: await read($, deciding) ? 'deciding' : await read($, paused) ? 'paused' : p?.by === 'manual' ? 'manual' : s.effortAuto ? 'auto' : 'off',
       ...(p?.why ? { why: p.why, by: p.by } : {}), ...(await read($, decidingSince) !== null ? { since: (await read($, decidingSince))! } : {}) },
     model: await read($, modelIs) ? modelName((await read($, modelIs))!) : null,
-    context: await read($, context), cache: await read($, cache), warm: { ...w, on: s.keepWarm },
+    context: await read($, context), cache: await read($, cache), warm: { ...w, on: await keepWarmOn($, s), ...(await read($, warmHere) !== null ? { here: true } : {}) },
     limit: l ? { ...l, save: saving } : null, route: record ? routeOf(record) : null, notice: await read($, line),
     auto: s.effortAuto, handoff: await read($, advice) ? 'advised' : s.handoffButton === 'always' ? 'always' : 'off',
     agents: { live: list.filter(a => ['running', 'waiting'].includes(a.state)).length, total: list.length },
@@ -1056,6 +1087,7 @@ async function alertView($: EngineInterface, now: number): Promise<AlertView | n
   const which = bandPriority({ panel: await read($, panel), judgeDown: d === 'down' || (!!downReason && downReason !== await read($, judgeDownHidden)),
     hot: d === 'hot' || hotAlert(h, await read($, hotHidden)), result: !!writing || !!result,
     cold: d === 'cold' || coldAlert(m, c?.tokens ?? 0, now, await read($, coldHidden)),
+    kept: d === 'kept' || keptAlert(await read($, kept), m, now),
     swamp: d === 'swamp' || (s.swampAlert && !await read($, busy) && swampAlert(swamped(c, s.swampAt), await read($, swampHidden))) })
   if (which === 'compact') return { kind: 'compactNote', draft: await read($, compactNote) }
   if (which === 'handoff') return { kind: 'handoffChoice', handoffKind: await read($, handoffChoiceKind), after: await read($, handoffChoiceAfter) }
@@ -1068,22 +1100,27 @@ async function alertView($: EngineInterface, now: number): Promise<AlertView | n
     return { kind: 'result', stage, handoffKind: writing.kind, ...(detail ? { detail } : {}) }
   }
   if (which === 'cold') return { kind: 'cold', tokens: d === 'cold' ? 180000 : c!.tokens, idleMinutes: m ? Math.round((now - m.lastReplyAt) / 60000) : 61 }
+  if (which === 'kept') {
+    const k = d === 'kept' ? { pings: 2, tokens: 312000 } : (await read($, kept)) ?? { pings: 0, tokens: 0 }
+    return { kind: 'kept', pings: k.pings, tokens: k.tokens, minutesLeft: Math.ceil(((d === 'kept' ? now + 47 * 60000 : m!.expiresAt) - now) / 60000) }
+  }
   if (which === 'swamp') return { kind: 'swamp', percent: d === 'swamp' ? 65 : c!.percent, tokens: d === 'swamp' ? 160000 : c!.tokens }
   return null
 }
 /**
- * A prompt sent while the cold, heavy or hot band shows counts as having seen it: it comes back
- * only on its own next occasion (the next expiry, 15 more points of context, 10 more of the plan
- * window), never after every message.
+ * A prompt sent while the cold, kept, heavy or hot band shows counts as having seen it: it comes
+ * back only on its own next occasion (the next expiry, one more ping, 15 more points of context,
+ * 10 more of the plan window), never after every message.
  */
 async function markSeen($: EngineInterface): Promise<void> {
   const view = await alertView($, await $.clock.now())
-  if (view && (view.kind === 'cold' || view.kind === 'swamp' || view.kind === 'hot')) await dismiss($, view)
+  if (view && (view.kind === 'cold' || view.kind === 'kept' || view.kind === 'swamp' || view.kind === 'hot')) await dismiss($, view)
 }
 async function dismiss($: EngineInterface, view: AlertView): Promise<void> {
   await update($, demo, () => null)
   if (view.kind === 'hot') await update($, hotHidden, () => view.percent)
   else if (view.kind === 'cold') await update($, coldHidden, () => true)
+  else if (view.kind === 'kept') await update($, kept, () => null)
   else if (view.kind === 'swamp') await update($, swampHidden, () => view.percent)
   else if (view.kind === 'judgeDown') await update($, judgeDownHidden, () => view.reason)
   else if (view.kind === 'result') { await update($, resultCard, () => null); await update($, handoff, () => null) }
@@ -1133,6 +1170,7 @@ async function prepareStep($: EngineInterface, e: TurnStepInput): Promise<TurnSt
     if (previousModel !== null) {
       await update($, cache, () => null)
       await update($, lastRealReplyAt, () => null)
+      if (await read($, kept)) await update($, kept, () => null)
     }
   }
   const safe = isCacheSafeModel(e.model)
@@ -1200,6 +1238,7 @@ export const register: Register = on => {
           await update($, cache, () => null)
           await update($, context, () => null)
           await update($, lastRealReplyAt, () => null)
+          if (await read($, kept)) await update($, kept, () => null)
         }
         if (e.model) await update($, modelIs, () => e.model!)
         await update($, paused, () => e.model ? !isCacheSafeModel(e.model) : false)
@@ -1291,6 +1330,7 @@ export const register: Register = on => {
           const memo = nextMemo(await read($, cache), answer.usage, now)
           await update($, cache, () => memo)
           if (await read($, coldHidden)) await update($, coldHidden, () => false)
+          if (await read($, kept)) await update($, kept, () => null)
           await update($, lastRealReplyAt, () => now)
           if ((await read($, warm)).stopped !== undefined) await update($, warm, value => ({ ...value, stopped: undefined }))
         }
@@ -1403,6 +1443,7 @@ export const register: Register = on => {
       if (!answer.isAnswered || answer.text.trim().length <= 200) throw new Error(t(language, 'toasts.summaryEmpty'))
       await update($, cache, () => null)
       await update($, context, () => null)
+      if (await read($, kept)) await update($, kept, () => null)
       await update($, resultCard, () => ({ stage: 'compacted' }))
       return compactResult(answer.text)
     } catch (error) {
@@ -1425,7 +1466,7 @@ export const register: Register = on => {
       else if (sub === 'log') await toggleLog($)
       else if (sub === 'agents') await toggleAgents($)
       else if (sub === 'bar') await toggleBar($)
-      else if (['cold', 'swamp', 'hot', 'down'].includes(sub)) { await update($, panel, () => null); await update($, demo, () => sub as 'cold' | 'swamp' | 'hot' | 'down') }
+      else if (['cold', 'swamp', 'hot', 'down', 'kept'].includes(sub)) { await update($, panel, () => null); await update($, demo, () => sub as 'cold' | 'swamp' | 'hot' | 'down' | 'kept') }
       else return { text: t(language, 'commands.help') }
       return { text: t(language, 'commands.done', { command: sub }) }
     } catch (error) { await report($, 'ripple command', error); return next(e) }
@@ -1439,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.
@@ -37,6 +63,14 @@ export function coldAlert(memo: CacheMemo | null, contextTokens: number, now: nu
   return !hidden && memo !== null && memo.expiresAt <= now && contextTokens >= 150000
 }
 
+/**
+ * Keep-warm held the cache while the person was away: at least one ping read cache tokens and the
+ * memo says the cache is still warm. Once it has expired the cold card is the truth, never this.
+ */
+export function keptAlert(kept: { pings: number; tokens: number } | null, memo: CacheMemo | null, now: number): boolean {
+  return kept !== null && kept.pings > 0 && memo !== null && memo.expiresAt > now
+}
+
 export function hotAlert(hot: Hot | null, hidden: number | null): boolean {
   return hot !== null && hot.percent >= 80 && (hidden === null || hot.percent >= hidden + 10)
 }
@@ -54,9 +88,9 @@ export function swampAlert(percent: number | null, hidden: number | null): boole
 /** Rendering consumes eligibility, keeping dismissal and idle decisions outside drawing code. */
 export function bandPriority(state: {
   panel?: 'settings' | 'compact' | 'handoff' | 'setup' | null
-  judgeDown?: boolean; hot?: boolean; result?: boolean; cold?: boolean; swamp?: boolean
-}): 'settings' | 'compact' | 'handoff' | 'setup' | 'judgeDown' | 'hot' | 'result' | 'cold' | 'swamp' | 'dashboard' {
+  judgeDown?: boolean; hot?: boolean; result?: boolean; cold?: boolean; swamp?: boolean; kept?: boolean
+}): 'settings' | 'compact' | 'handoff' | 'setup' | 'judgeDown' | 'hot' | 'result' | 'cold' | 'swamp' | 'kept' | 'dashboard' {
   if (state.panel) return state.panel
-  for (const band of ['judgeDown', 'hot', 'result', 'cold', 'swamp'] as const) if (state[band]) return band
+  for (const band of ['judgeDown', 'hot', 'result', 'cold', 'swamp', 'kept'] as const) if (state[band]) return band
   return 'dashboard'
 }

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/alerts.tsx

@@ -12,7 +12,7 @@ import { t } from '../i18n'
 import type { RenderNode } from 'claude-code'
 
 import type { HandoffKind, Settings } from '../../types'
-import { CELL_PX, MUTE, SUB, TONE, pillArt } from './art'
+import { CELL_PX, MUTE, ROW_PX, SUB, TONE, pillArt } from './art'
 import type { Sea, Tone } from './art'
 import { capsule, closeButton, pill, ripple, segmented as drawnSegmented, well } from './kit'
 import type { SegmentOption } from './kit'
@@ -61,6 +61,14 @@ function cardOf(frame: Frame, alert: AlertView, a: AlertActions): Card {
         quiet: [handoff],
         close: notNow,
       }
+    case 'kept':
+      return {
+        key: 'kept',
+        face: 'pleased',
+        title: t(L, 'alerts.keptTitle'),
+        body: t(L, 'alerts.keptBody', { pings: alert.pings, tokens: compactNumber(alert.tokens), minutes: alert.minutesLeft }),
+        close: { key: 'dismiss', label: t(L, 'alerts.gotIt'), hotkey: 'x', onPress: a.dismiss },
+      }
     case 'swamp':
       return {
         key: 'swamp',
@@ -205,6 +213,8 @@ function seaOf(card: Card, alert: AlertView): Omit<Sea, 'at'> {
   switch (card.key) {
     case 'cold':
       return { tone: 'ice', weather: 'snow', motes: true }
+    case 'kept':
+      return { tone: 'amber', weather: 'sparkles', ripples: 'calm' }
     case 'swamp':
       return { tone: 'amber', weather: 'bubbles', ripples: 'calm' }
     case 'hot':
@@ -329,7 +339,8 @@ function drawnAlert(el: Els, frame: Frame, alert: AlertView, a: AlertActions): R
     </Box>
   ) : (
     <Box key="top" flexDirection="row" alignItems="flex-start" columnGap={2} width="100%" minWidth={0}>
-      {face}
+      {/* Beside two lines 리플이 sits at their middle, not on the title's line (2026-10-14: it rode high). */}
+      <Box key="face" alignSelf="center" flexShrink={0}>{face}</Box>
       <Box key="say" flexDirection="column" rowGap={1} flexGrow={1} flexShrink={1} minWidth={0}>
         {title}
         {body}
@@ -339,10 +350,12 @@ function drawnAlert(el: Els, frame: Frame, alert: AlertView, a: AlertActions): R
       {actionsBelow ? null : buttons}
     </Box>
   )
+  const rows = oneRow ? 2 : 4 + (more.length ? 3.2 : 0) + (actionsBelow ? 2 : 0) + (frame.columns < 60 ? 3 : 0)
   return capsule(el, frame, {
     key: 'alert-' + card.key,
-    sea: { ...sea, reach: 130, at: { x: 1.5 * CELL_PX + CARD_FACE / 2, y: 0.5 * 19 * 0.5 + CARD_FACE / 2 } },
-    rows: oneRow ? 2 : 4 + (more.length ? 3.2 : 0) + (actionsBelow ? 2 : 0) + (frame.columns < 60 ? 3 : 0),
+    // The light comes from 리플이: on the title's line in one row, at the card's middle beside more.
+    sea: { ...sea, reach: 130, at: { x: 1.5 * CELL_PX + CARD_FACE / 2, y: oneRow ? 0.5 * ROW_PX * 0.5 + CARD_FACE / 2 : rows * ROW_PX / 2 } },
+    rows,
     children: [top],
   })
 }

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/band.tsx

@@ -596,7 +596,7 @@ function controlsDrawn(el: Els, frame: Frame, view: DashboardView, actions: Band
     ? { key: 'auto', cells: toggleCells(autoLabel), node: toggle(el, 'auto', view.auto, autoLabel, actions.toggleAuto, view.effort.mode === 'deciding', tipScope('auto')), tip: autoTip }
     : { key: 'auto', cells: SWITCH_ONLY, node: lit(el, 'auto', SWITCH_ONLY, [pic(el, 'auto', switchArt(view.auto, view.effort.mode === 'deciding'), autoLabel, 36, 22), press(el, 'auto', SWITCH_ONLY * CELL_PX, actions.toggleAuto)], 0.25, tipScope('auto')), tip: autoTip })
   const warmLabel = t(L, 'band.warm')
-  out.push(iconControl(el, 'warm', iconArt('flame', view.warm.on, 'amber'), ICON_PX, warmLabel, t(L, 'band.warmAlt', { state: state(view.warm.on) }) + ' · ' + t(L, 'settings.warmLine'), actions.toggleWarm, words.includes('warm') ? warmLabel : undefined, view.warm.on ? TONE.amber.text : SUB))
+  out.push(iconControl(el, 'warm', iconArt('flame', view.warm.on, 'amber'), ICON_PX, warmLabel, t(L, 'band.warmAlt', { state: state(view.warm.on) }) + ' · ' + t(L, view.warm.here ? 'band.warmHere' : 'settings.warmLine'), actions.toggleWarm, words.includes('warm') ? warmLabel : undefined, view.warm.on ? TONE.amber.text : SUB))
   const agentsLabel = t(L, 'band.agents')
   const live = view.agents.live
   // The live count sits on the icon's shoulder, in one picture of one width: no width change.

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/ui/view.ts

@@ -65,7 +65,8 @@ export type DashboardView = {
   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 }
+  /** `here`: this chat differs from Settings, set by the band's flame. */
+  warm: { on: boolean; pings: number; cost: number; stopped?: string; here?: boolean }
   /** The hottest plan window, shown when present. */
   limit: { kind: string; percent: number; resetsAt?: string; save: boolean } | null
   route: RouteView | null
@@ -113,6 +114,8 @@ export type ResultStage = 'handingOff' | 'handoffReady' | 'handoffDone' | 'compa
 export type AlertView =
   /** The cache expired on a big chat: the next prompt re-reads it all. */
   | { kind: 'cold'; tokens: number; idleMinutes: number }
+  /** Keep-warm held the cache while the person was away. */
+  | { kind: 'kept'; pings: number; tokens: number; minutesLeft: number }
   /** Context is heavy. */
   | { kind: 'swamp'; percent: number; tokens: number }
   /** A plan window at or above 80%. */

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('; ') } : {}) }
       }