clauderipple 0.9.4 → 0.10.0

package/dist/mod/hooks/modes.ts

@@ -1,7 +1,7 @@
 // Operating modes in the session (docs/specs/2026-10-12-worker-tiers.md "Operating modes"): which
 // mode is on, when it ends by itself, and the eager-delegation note. Pure; register.tsx wires them.
 
-import type { Hot, Mode, Settings } from '../types'
+import type { Hot, LimitItem, Mode, Settings } from '../types'
 
 /** The mode that is on, if the settings name one that exists. */
 export function activeModeOf(s: Pick<Settings, 'modes' | 'activeMode'>): Mode | undefined {
@@ -91,3 +91,58 @@ export function modeOver(mode: Pick<Mode, 'until'>, since: number | undefined, n
   const passed = (at: number) => at > since && at <= now
   return windows.some(w => passed(w.at) || (w.windowMs !== undefined && passed(w.at - w.windowMs)))
 }
+
+/** The configured providers of ChatGPT type, from GET /api/status `providers` (name → {type}). */
+export function chatgptProviders(status: unknown): string[] {
+  const providers = record(status).providers
+  if (!providers || typeof providers !== 'object' || Array.isArray(providers)) return []
+  return Object.entries(providers as Record<string, unknown>)
+    .filter(([, value]) => record(value).type === 'chatgpt')
+    .map(([name]) => name)
+}
+
+/**
+ * Every signed-in ChatGPT account's known windows as the limits row reads them, from GET
+ * /api/chatgpt-accounts (`quota.rate_limits.{primary,secondary}` with `reset_at` in epoch
+ * seconds or ms, or `reset_after_seconds` from the snapshot's `at`, and `window_minutes`;
+ * the same shape `quotaWindows` reads). Paused and needs-login accounts are left out (and take
+ * no number), and so is an account with no snapshot. `account` numbers the accounts kept, in
+ * answer order. A snapshot is not aged out: the router takes it from the account's own replies,
+ * so an account idle for an hour holds an hour-old figure that is still right (measured
+ * 2026-10-15: 30 minutes old between uses). Only a window whose reset has passed is dropped,
+ * since its figure no longer stands.
+ */
+export function gptLimitsFrom(body: unknown, provider: string, now: number): LimitItem[] {
+  const accounts = record(body).accounts
+  if (!Array.isArray(accounts)) return []
+  const kept = accounts.map(record).filter(account => account.state !== 'paused' && account.state !== 'needs-login' && account.paused !== true)
+  const out: LimitItem[] = []
+  kept.forEach((account, index) => {
+    const quota = record(account.quota)
+    const at = quota.at
+    if (typeof at !== 'number') return
+    const limits = record(quota.rate_limits)
+    for (const key of ['primary', 'secondary']) {
+      const window = record(limits[key])
+      const used = window.used_percent
+      if (typeof used !== 'number' || !Number.isFinite(used)) continue
+      const minutes = window.window_minutes
+      const resetAt = typeof window.reset_at === 'number' ? (window.reset_at > 1e12 ? window.reset_at : window.reset_at * 1000)
+        : typeof window.reset_after_seconds === 'number' && typeof at === 'number' ? at + window.reset_after_seconds * 1000 : NaN
+      if (Number.isFinite(resetAt) && resetAt <= now) continue
+      const kind = minutes === 300 ? 'five_hour' : minutes === 10080 ? 'seven_day' : 'window'
+      out.push({
+        provider,
+        type: 'chatgpt',
+        title: 'GPT',
+        account: index,
+        kind,
+        label: '',
+        ...(typeof minutes === 'number' && minutes > 0 ? { windowMinutes: minutes } : {}),
+        percent: Math.round(used * 10) / 10,
+        ...(Number.isFinite(resetAt) ? { resetsAt: new Date(resetAt).toISOString() } : {}),
+      })
+    }
+  })
+  return out
+}

package/dist/mod/hooks/register.tsx

@@ -2,29 +2,32 @@
 // 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, 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 type { AgentRec, Effort, JudgeInput, JudgeKind, JudgeRun, LimitItem, ModSettingsSnapshot, Pick, Settings, StatusRequest, TierTarget, Verdict, WorkerCandidate, WorkerPick, WorkerVerdict } from '../types'
+import { MOD_SETTINGS_SCHEMA_VERSION, RUNG_EFFORT, applySettingsChanges, normalizeSettings, settingsChanges } from './settings'
+import { rungOf } from './ladder'
 import { debugText, langFrom, t } from './i18n'
 import type { Lang } from './i18n'
 import { EFFORT_JUDGE_SYSTEM, finalEffort, isCacheSafeModel, isShortFollowUp, jevEffortRequest, jevFailure, jevUsage, jevWorkerRequest, judgeContext, parseEffortVerdict, parseJevEffort, parseJevKey, parseJevWorker, shouldJudge } from './judge'
-import { AUTO_DESCRIPTION, WORKER_JUDGE_SYSTEM, agentProvider, candidateUsable, chatgptUsable, claudeCandidates, ladderOptionsFrom, ladderPick, parseWorkerVerdict, readMarker, routerModelOptions, spawnModel, spawnTitle, takesOver, workerJudgeInput, zenJev } from './workers'
+import { AUTO_DESCRIPTION, WORKER_JUDGE_SYSTEM, agentProvider, candidateUsable, chatgptUsable, claudeCandidates, ladderOptionsFrom, ladderPick, parseWorkerVerdict, readMarker, routerModelOptions, spawnModel, spawnTitle, takesOver, TIER_MARKERS, tierOf, workerJudgeInput, zenJev } from './workers'
 import { MARKER, agentModel, fixSpawn } from './worker'
-import { activeModeOf, claudeWindow, eagerNote, modeKey, modeOver, quotaWindows, resetProvider, routingSettings } from './modes'
+import { activeModeOf, chatgptProviders, claudeWindow, eagerNote, gptLimitsFrom, modeKey, modeOver, quotaWindows, resetProvider, routingSettings } from './modes'
 import type { QuotaWindow } from './modes'
 import type { Spawn, WorkerFix } from './worker'
 import { afterPing, nextMemo, restoreFromResume, shouldPing } from './cache'
-import { bandPriority, claudeLimitsFrom, coldAlert, hotAlert, hottest, keptAlert, saveUntil as limitSaveUntil, swampAlert, swamped } from './session'
+import { bandPriority, claudeLimitsFrom, claudeScopedFrom, coldAlert, hotAlert, hottest, hotWindowMoved, keptAlert, routerLimitItems, saveUntil as limitSaveUntil, swampAlert, swamped } from './session'
+import type { ScopedLimit } 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'
+import { addAgentStep, addJudge, addPrompt, addRequest, addWarm, addWorker, emptyStats, formatStats, sentEffort } from './stats'
 import { besideBand, renderBand, renderFooter } from './ui/band'
 import { renderAlert } from './ui/alerts'
 import { renderSettings } from './ui/settings'
 import { renderSetup } from './ui/setup'
-import { renderAgents } from './ui/agents'
+import { renderAgents, talkOf } from './ui/agents'
+import { toolDetail } from './ui/tools'
 import { renderLog } from './ui/log'
 import { EFFORTS, modelName, nextMinuteChange, routeOf, targetLabel } from './ui/view'
-import type { AlertActions, AlertView, BandActions, DashboardView, Frame, SettingsActions, SettingsView, SetupActions } from './ui/view'
+import type { AgentTalk, AgentsActions, AlertActions, AlertView, BandActions, DashboardView, Frame, SettingsActions, SettingsView, SetupActions } from './ui/view'
 
 const line = atom({ plugin: 'ripple', key: 'line' } as const, null)
 const last = atom({ plugin: 'ripple', key: 'last' } as const, null)
@@ -53,7 +56,9 @@ const lastRealReplyAt = atom({ plugin: 'ripple', key: 'lastRealReplyAt' } as con
 const context = atom({ plugin: 'ripple', key: 'context' } as const, null)
 const hot = atom({ plugin: 'ripple', key: 'hot' } as const, null)
 const limit = atom({ plugin: 'ripple', key: 'limit' } as const, null)
+const limits = atom({ plugin: 'ripple', key: 'limits' } as const, null)
 const hotHidden = atom({ plugin: 'ripple', key: 'hotHidden' } as const, null)
+const hotHiddenFor = atom({ plugin: 'ripple', key: 'hotHiddenFor' } 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)
@@ -82,6 +87,10 @@ const compactNote = atom({ plugin: 'ripple', key: 'compactNote' } as const, '')
 const effortMenuOpen = atom({ plugin: 'ripple', key: 'effortMenuOpen' } as const, false)
 const agentsOpen = atom({ plugin: 'ripple', key: 'agentsOpen' } as const, false)
 const agentsShowDone = atom({ plugin: 'ripple', key: 'agentsShowDone' } as const, false)
+const agentOpen = atom({ plugin: 'ripple', key: 'agentOpen' } as const, null)
+const agentEarlier = atom({ plugin: 'ripple', key: 'agentEarlier' } as const, 0)
+const agentRunsOpen = atom({ plugin: 'ripple', key: 'agentRunsOpen' } as const, [])
+const agentsTick = atom({ plugin: 'ripple', key: 'agentsTick' } as const, 0)
 const jev = atom({ plugin: 'ripple', key: 'jev' } as const, { source: null, test: { state: 'idle' } })
 const routerModels = atom({ plugin: 'ripple', key: 'routerModels' } as const, [])
 const ladderOptions = atom({ plugin: 'ripple', key: 'ladderOptions' } as const, null)
@@ -144,12 +153,18 @@ async function rippleHome($: EngineInterface): Promise<string> {
 }
 // The fs API has no append: serialize read/write pairs so concurrent picks in this mod survive.
 let workerLogWork: Promise<void> = Promise.resolve()
+/**
+ * Lines the pick log keeps. Each delegation writes up to three (pick, shadow verdict, outcome), so
+ * 300 lines held only a few days; weighing the judge against the main chat's tier markers needs
+ * weeks (2026-10-15).
+ */
+const PICK_LOG_LINES = 3000
 async function persistWorkerPick($: EngineInterface, entry: Record<string, unknown>): Promise<void> {
   const work = workerLogWork.then(async () => {
     try {
       const path = `${await rippleHome($)}/logs/worker-picks.jsonl`
       const old = await $.fs.exists(path) ? await $.fs.read(path) : ''
-      const lines = old.split('\n').filter(line => line.trim()).slice(-299)
+      const lines = old.split('\n').filter(line => line.trim()).slice(-(PICK_LOG_LINES - 1))
       await $.fs.write(path, [...lines, JSON.stringify(entry)].join('\n') + '\n')
     } catch (error) { await report($, 'worker pick log', error) }
   })
@@ -346,7 +361,15 @@ async function toggleLog($: EngineInterface): Promise<boolean> {
   const language = await read($, lang)
   const open = await isLogUp($)
   if (open) await $.ui.close({ id: LOG_PANE })
-  else await $.ui.open({ id: LOG_PANE, title: t(language, 'commands.logTitle') })
+  else {
+    // The surface may decline to draw the pane; say why rather than doing nothing on a press.
+    const opened = await $.ui.open({ id: LOG_PANE, title: t(language, 'commands.logTitle') })
+    if (!opened.isPlaced) {
+      const why = 'reason' in opened && opened.reason ? String(opened.reason) : 'not placed'
+      $.ui.toast(t(language, 'toasts.logNotPlaced', { reason: why }))
+      await report($, 'log pane', why)
+    }
+  }
   await syncPanes($)
   if (!open) await refreshRouter($)
   return !open
@@ -412,6 +435,18 @@ async function workerFiles($: EngineInterface): Promise<Map<string, string>> {
   }
   return files
 }
+/**
+ * The provider a started agent runs on, for its card's dot: its worker file's (`via <provider>.`),
+ * Anthropic for a Claude id, else the router's catalogue entry for the id.
+ */
+async function spawnProvider($: EngineInterface, subagentType: string, model: string): Promise<string | undefined> {
+  const file = (await workerFiles($)).get(subagentType)
+  const fromFile = file ? agentProvider(file) : undefined
+  if (fromFile) return fromFile
+  const id = model.replace(/@[^@]*$/, '')
+  if (/^(?:sonnet|opus|haiku|fable|mythos|claude-)/.test(id)) return 'anthropic'
+  return (await read($, routerModels)).find(m => m.value === id)?.provider
+}
 async function workerFix($: EngineInterface, spawn: Spawn): Promise<WorkerFix | null> {
   const text = await optionalFile($, `${await rippleHome($)}/generated-agents.json`)
   if (!text || !strings(object(JSON.parse(text)).agents).includes(spawn.subagentType)) return null
@@ -660,7 +695,9 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   const pinnedCandidates = [...[...files].flatMap(([agent, file]) => { const model = agentModel(file)?.replace(/@[^@]*$/, ''); const provider = agentProvider(file); return model && provider ? [{ target: { agent }, model, provider }] : [] }), ...claudeCandidates()]
   const usable = await availability($)
   const marker = readMarker(e.prompt)
-  const explicit = marker && !['auto', 'ripple'].includes(marker.name) ? marker : null
+  const tier = tierOf(marker)
+  const explicit = marker && !tier && !['auto', 'ripple'].includes(marker.name) ? marker : null
+  const id = (await $.clock.now()).toString(36) + Math.random().toString(36).slice(2, 8)
   let verdict: WorkerVerdict = { domain: 'general', level: 'standard', effort: 'high', why: t(language, 'toasts.judgeUnavailable') }
   let by: WorkerPick['by'] = 'default'
   let ms = 0
@@ -673,6 +710,13 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
     target = name ? { agent: name } : { agent: 'general-purpose', model: explicit.name }
     verdict = { domain: 'general', level: 'standard', effort: effortOf(explicit.level) ?? 'high', why: t(language, 'toasts.explicitMarker') }
     by = 'marker'
+  } else if (tier) {
+    // The main chat named the tier. The judge still rates the same brief, unawaited, so the log
+    // can later say which of the two was right (see shadowJudge).
+    const named = TIER_MARKERS[tier]!
+    verdict = { domain: 'general', ...named, effort: RUNG_EFFORT[rungOf(named)], why: t(language, 'toasts.sessionTier', { tier }) }
+    by = 'session'
+    void shadowJudge($, s, id, { description: e.description, prompt: e.prompt })
   } else {
     const judged = await judge($, s, { description: e.description, prompt: e.prompt }, true)
     if (judged.verdict && 'domain' in judged.verdict) { rawVerdict = judged.verdict; verdict = judged.verdict; by = judged.by }
@@ -700,18 +744,34 @@ async function requestPick($: EngineInterface, e: AgentSpawnInput, s: Settings):
   const model = spawnModel(selected, verdict.effort, files.has(selected.agent) ? agentModel(files.get(selected.agent)!) : undefined)
   let prompt = e.prompt
   if (marker) prompt = prompt.replace(MARKER, '').replace(/^\s*\n/, '')
-  const value: WorkerPick = { ...verdict, ...resolved, target: selected, by, ms, ...(fallbackReason ? { fallbackReason } : {}) }
+  const value: WorkerPick = { ...verdict, ...resolved, target: selected, by, ms, id, ...(fallbackReason ? { fallbackReason } : {}) }
   // The verdict behind a pick is otherwise only in the agents panel; one debug line per pick keeps
   // it checkable: what the judge said, the rung it landed on and what ran.
   const entry = { task: e.description.slice(0, 200), domain: value.domain, level: value.level, kind: value.kind ?? 'do', sure: value.sure, rung: value.rung, position: value.position, skipped: value.skipped, target: value.target, model: model ?? null, effort: value.effort, by, ...(mode ? { mode: mode.name } : {}), ...(fallbackReason ? { fallbackReason } : {}) }
   await $.ui.log('ClaudeRipple worker pick: ' + JSON.stringify(entry), { to: 'debug' })
-  await persistWorkerPick($, { ...entry, at: new Date(now).toISOString(), verdict: rawVerdict, by: by === 'marker' || by === 'default' ? by : 'judge', judge: by === 'marker' || by === 'default' ? null : by, ms, ...(judgeError ? { error: judgeError } : {}) })
+  // The brief itself is never logged (it can hold anything); its length is. To re-judge a pick,
+  // its brief is in the session's own transcript under the same description.
+  const named = by === 'marker' || by === 'default' || by === 'session'
+  await persistWorkerPick($, { type: 'pick', id, ...entry, at: new Date(now).toISOString(), verdict: rawVerdict, by: named ? by : 'judge', judge: named ? null : by, ...(tier ? { tier } : {}), ms, ...(judgeError ? { error: judgeError } : {}), promptChars: e.prompt.length })
   if (fallbackReason) await $.ui.toast(t(language, 'toasts.workerFallback', { reason: fallbackReason, name: targetLabel(selected, language) }))
   await update($, lastSpawn, () => value)
   await update($, stats, current => addWorker(current, verdict.level))
   return { input: { ...e, subagentType: selected.agent, model, prompt }, pick: value }
 }
 
+/**
+ * What the judge would have said of a brief the main chat already tiered: logged beside the pick
+ * (same `id`), never awaited by the spawn, never acted on. Together with each pick's outcome it is
+ * what decides later whether the judge stays.
+ */
+async function shadowJudge($: EngineInterface, s: Settings, id: string, input: { description: string; prompt: string }): Promise<void> {
+  try {
+    const judged = await judge($, s, input, true)
+    const verdict = judged.verdict && 'domain' in judged.verdict ? judged.verdict : null
+    await persistWorkerPick($, { type: 'shadow', pick: id, at: new Date(await $.clock.now()).toISOString(), verdict, rung: verdict ? rungOf(verdict) : null, judge: judged.by, ms: judged.ms, ...(judged.error ? { error: judged.error } : {}) })
+  } catch (error) { await report($, 'shadow judge', error) }
+}
+
 async function toggleAuto($: EngineInterface): Promise<void> {
   const s = await currentSettings($)
   await saveSettings($, { ...s, effortAuto: !s.effortAuto })
@@ -941,6 +1001,81 @@ async function routerClaudeLimits($: EngineInterface): Promise<SessionRateLimit[
     return status.ok ? claudeLimitsFrom(JSON.parse(status.text), await $.clock.now()) : []
   } catch (error) { await report($, 'claude limits', error); return [] }
 }
+/** The router's figures for the Claude login (5-hour, weekly, per-model weeklies), at most one
+ * status lookup a minute and only while the limits row can show them; a failure keeps the last
+ * good numbers rather than blanking them. */
+let routerClaudeAt = 0
+let routerClaudeCache: { limits: SessionRateLimit[]; scoped: ScopedLimit[] } = { limits: [], scoped: [] }
+async function routerClaude($: EngineInterface): Promise<{ limits: SessionRateLimit[]; scoped: ScopedLimit[] }> {
+  const now = await $.clock.now()
+  if (!(await currentSettings($)).extras.includes('limits') || now - routerClaudeAt < 60_000) return routerClaudeCache
+  routerClaudeAt = now
+  try {
+    const status = await $.http.fetch(`${await adminUrl($)}/api/status`)
+    if (status.ok) {
+      const body: unknown = JSON.parse(status.text)
+      routerClaudeCache = { limits: claudeLimitsFrom(body, now), scoped: claudeScopedFrom(body, now) }
+    }
+  } catch (error) { await report($, 'claude limits row', error) }
+  return routerClaudeCache
+}
+/**
+ * The limits row as a router that predates `GET /api/limits` still answers it: Claude's plan in the
+ * unified shape, from the older `/api/status` and `/api/chatgpt-accounts` routes. Kept so the row
+ * shows exactly as before until the router is restarted onto the new endpoint.
+ */
+async function fallbackLimits($: EngineInterface): Promise<LimitItem[]> {
+  const now = await $.clock.now()
+  const fromRouter = await routerClaude($)
+  const claudeChat = /^claude-/.test(await $.session.model())
+  // The 5-hour and the weekly (one each, the hotter reading winning when both sources name it), then
+  // the per-model weeklies the router reports. Claude's plan shows whatever this chat runs on.
+  const usage = claudeChat ? (await $.session.usage()).rateLimits : []
+  const mains = new Map<'five_hour' | 'seven_day', SessionRateLimit>()
+  for (const w of [...usage, ...fromRouter.limits]) {
+    if (w.kind !== 'five_hour' && w.kind !== 'seven_day') continue
+    const prev = mains.get(w.kind)
+    if (!prev || w.percentUsed > prev.percentUsed) mains.set(w.kind, w)
+  }
+  const items: LimitItem[] = (['five_hour', 'seven_day'] as const)
+    .flatMap(kind => mains.get(kind) ? [mains.get(kind)!] : [])
+    .map(w => ({ provider: 'claude', type: 'anthropic', title: 'Claude', account: 0, kind: w.kind as 'five_hour' | 'seven_day', label: '', percent: w.percentUsed, ...(w.resetsAt ? { resetsAt: w.resetsAt } : {}) }))
+  for (const s of fromRouter.scoped) items.push({ provider: 'claude', type: 'anthropic', title: 'Claude', account: 0, kind: 'scoped', label: s.name, percent: s.percent, ...(s.resetsAt ? { resetsAt: s.resetsAt } : {}) })
+  const admin = await adminUrl($)
+  const status = await $.http.fetch(`${admin}/api/status`)
+  if (status.ok) for (const provider of chatgptProviders(JSON.parse(status.text))) {
+    const response = await $.http.fetch(`${admin}/api/chatgpt-accounts?provider=${encodeURIComponent(provider)}`)
+    if (!response.ok) continue
+    const body: unknown = JSON.parse(response.text)
+    // The router answers for its first ChatGPT provider when the name is not one: not this provider.
+    if (object(body).provider !== provider) continue
+    items.push(...gptLimitsFrom(body, provider, now))
+  }
+  return items
+}
+/**
+ * The whole limits row from the router's `GET /api/limits` — every provider whose quota it can read,
+ * Claude first — at most one round a minute and only while the row can show it. On a router that
+ * predates the endpoint (404) the older per-provider routes answer instead, so the row shows before
+ * the router is restarted. A failure keeps the last good row rather than blanking it, and the state
+ * is written only when it moved: a redraw that shows nothing new is wasted (each answer is drawn
+ * afresh).
+ */
+let limitsAt = 0
+async function refreshLimits($: EngineInterface): Promise<void> {
+  if (!(await currentSettings($)).extras.includes('limits')) return
+  const now = await $.clock.now()
+  if (now - limitsAt < 60_000) return
+  limitsAt = now
+  try {
+    const admin = await adminUrl($)
+    const response = await $.http.fetch(`${admin}/api/limits`)
+    let items: LimitItem[] | null = null
+    if (response.ok) items = routerLimitItems(JSON.parse(response.text), now)
+    else if (response.status === 404) items = await fallbackLimits($)
+    if (items && !same(items, await read($, limits))) await update($, limits, () => items)
+  } catch (error) { await report($, 'limits', error) }
+}
 async function refreshUsage($: EngineInterface): Promise<void> {
   const usage = await $.session.usage()
   const c = usage.context
@@ -956,10 +1091,18 @@ async function refreshUsage($: EngineInterface): Promise<void> {
   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)
+  // A put-off lasts until the window it was put off for moves on (session.ts hotWindowMoved). A
+  // put-off from an older mod carries no window: it adopts the current one.
+  if (await read($, hotHidden) !== null) {
+    const putOffFor = await read($, hotHiddenFor)
+    if (!putOffFor) { if (h) await update($, hotHiddenFor, () => h) }
+    else if (hotWindowMoved(putOffFor, h)) { await update($, hotHidden, () => null); await update($, hotHiddenFor, () => null) }
+  }
   if (JSON.stringify(h) !== JSON.stringify(previous)) await update($, hot, () => h)
   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
+  // The limits row itself is read from the router's `/api/limits` (refreshLimits); the host's own
+  // windows still bind the first row's limit and the hot alert here, as they always have.
   // Check the previous binding deadline before a rolled-forward snapshot replaces it.
   await endModeIfOver($)
   if (JSON.stringify(l) !== JSON.stringify(await read($, limit))) await update($, limit, () => l)
@@ -997,6 +1140,7 @@ async function tick($: EngineInterface): Promise<void> {
   ticking = true
   try {
     await refreshUsage($)
+    await refreshLimits($)
     const now = await $.clock.now()
     const list = await read($, agents)
     if (list.some(a => a.state === 'running' && a.toolSince !== undefined && now - a.toolSince >= 8000)) {
@@ -1044,6 +1188,18 @@ function startTimers($: EngineInterface): void {
   $.clock.after(1, async () => { await refreshRouter($); await tick($) })
   $.clock.every(3000, async () => { await refreshRouter($) })
   $.clock.every(15000, async () => { await tick($) })
+  $.clock.every(1000, async () => { await agentsClock($) })
+}
+/**
+ * The Agents pane's clocks: each second an agent runs while the pane is open, one write that only
+ * the pane reads, so its elapsed times tick and nothing else redraws.
+ */
+async function agentsClock($: EngineInterface): Promise<void> {
+  try {
+    if (!(await read($, agents)).some(a => a.state === 'running' || a.state === 'waiting')) return
+    if (!(await $.ui.panes()).some(p => p.id === AGENTS_PANE)) return
+    await update($, agentsTick, n => n + 1)
+  } catch (error) { await report($, 'agents clock', error) }
 }
 
 async function dashboard($: EngineInterface, working: boolean): Promise<DashboardView> {
@@ -1061,6 +1217,7 @@ async function dashboard($: EngineInterface, working: boolean): Promise<Dashboar
     model: await read($, modelIs) ? modelName((await read($, modelIs))!) : null,
     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),
+    limits: await read($, limits) ?? [],
     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 },
     logOpen: await read($, logOpen), agentsOpen: await read($, agentsOpen), effortMenu: await read($, effortMenuOpen),
@@ -1075,7 +1232,7 @@ async function frameOf($: EngineInterface, e: RenderInput): Promise<Frame> {
   const s = await currentSettings($)
   const columns = 'bodyColumns' in e.props ? e.props.bodyColumns : e.viewport?.columns ?? 100
   const maxRows = 'maxRows' in e.props ? e.props.maxRows : 'scroll' in e.props ? e.props.scroll.bodyRows : 1
-  return { surface: e.surface, columns, maxRows, now: await $.clock.now(), appearance: s.appearance, lang: await read($, lang) }
+  return { surface: e.surface, columns, maxRows, now: await $.clock.now(), appearance: s.appearance, skin: s.skin, lang: await read($, lang) }
 }
 async function alertView($: EngineInterface, now: number): Promise<AlertView | null> {
   const language = await read($, lang)
@@ -1122,8 +1279,11 @@ async function markSeen($: EngineInterface): Promise<void> {
 }
 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)
+  if (view.kind === 'hot') {
+    const current = await read($, hot)
+    await update($, hotHidden, () => view.percent)
+    await update($, hotHiddenFor, () => current)
+  } 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)
@@ -1154,10 +1314,33 @@ function alertActions($: EngineInterface, view: AlertView): AlertActions {
   return { compact: note => runCompact($, note), clear: async () => { await update($, panel, () => null); await $.command.run({ command: 'clear', args: '' }) }, handoff: () => openHandoff($), dismiss: () => dismiss($, view), toggleSave: () => toggleSave($), openSettings: () => startPanel($, 'settings'),
     noteInput: text => update($, compactNote, () => text), setHandoffKind: kind => update($, handoffChoiceKind, () => kind), setHandoffAfter: after => update($, handoffChoiceAfter, () => after), go: () => queueHandoff($), copy: () => copyHandoff($), openNew: () => moveToNewSession($) }
 }
-function toolLine(e: ToolCallInput): string {
-  const fields = object(e)
-  const detail = fields.command ?? fields.file_path ?? fields.pattern ?? fields.query ?? fields.url ?? fields.description ?? ''
-  return `${e.tool} ${String(detail).split('\n')[0]}`.trim().slice(0, 70)
+function agentsActions($: EngineInterface): AgentsActions {
+  return {
+    toggleDone: () => update($, agentsShowDone, value => !value),
+    open: async id => { await update($, agentEarlier, () => 0); await update($, agentRunsOpen, () => []); await update($, agentOpen, () => id) },
+    // Back on the list, the runs unfolded in that conversation fold again: it opens folded next time.
+    back: async () => { await update($, agentRunsOpen, () => []); await update($, agentOpen, () => null) },
+    earlier: () => update($, agentEarlier, n => n + 1),
+    toggleRun: id => update($, agentRunsOpen, ids => ids.includes(id) ? ids.filter(i => i !== id) : [...ids, id]),
+  }
+}
+/**
+ * An agent's conversation for the Agents pane, read again at each draw: its steps and tool calls
+ * redraw the pane while it runs, so what it says shows as it says it. Paths in its tool calls read
+ * relative to the session's folder, or under `~`.
+ */
+async function agentTalk($: EngineInterface, id: string): Promise<AgentTalk> {
+  try {
+    const found = await $.session.messages({ agentId: id })
+    if (!Array.isArray(found)) return { deny: found.deny }
+    const cwd = await $.session.cwd().catch(() => undefined)
+    return { entries: talkOf(found, { ...(cwd ? { cwd } : {}), home: await userHome($) }) }
+  } catch (error) { return { deny: reason(error) } }
+}
+/** What an agent is doing, in the words its conversation's tool rows use (tools.ts toolDetail): no leading `cd`, paths short. */
+async function toolLine($: EngineInterface, e: ToolCallInput): Promise<string> {
+  const cwd = await $.session.cwd().catch(() => undefined)
+  return `${e.tool} ${toolDetail(e.tool, object(e), { ...(cwd ? { cwd } : {}), home: await userHome($) })}`.trim().slice(0, 70)
 }
 async function prepareStep($: EngineInterface, e: TurnStepInput): Promise<TurnStepInput> {
   const language = await read($, lang)
@@ -1210,9 +1393,10 @@ export const register: Register = on => {
     const result = await next(e)
     jevBlips = 0
     try {
-      await loadSettings($)
+      // A failure here must not cost the commands: without them there is no /ripple to look with.
+      try { await loadSettings($); await $.ui.status(undefined) }
+      catch (error) { await report($, 'session.start settings', error) }
       const language = await read($, lang)
-      await $.ui.status(undefined)
       await $.command.register({ name: 'ripple', description: t(language, 'commands.description'), argumentHint: t(language, 'commands.argumentHint'), immediate: true })
       await $.command.register({ name: 'ripple-log', description: t(language, 'commands.logDescription'), immediate: true })
       await $.command.register({ name: 'ripple-bar', description: t(language, 'commands.barDescription'), immediate: true })
@@ -1327,7 +1511,8 @@ export const register: Register = on => {
       if (epoch !== generation) return answer
       if (ownFork) { if (answer.usage) forkUsage = answer.usage; return answer }
       if (e.agentId && answer.usage) {
-        await update($, agents, list => list.map(a => a.id === e.agentId ? { ...a, cost: a.cost + weighted(answer.usage!) } : a))
+        const effort = sentEffort(request.model, request.effort)
+        await update($, agents, list => list.map(a => a.id === e.agentId ? addAgentStep(a, answer.usage!, effort) : a))
       } else if (!e.agentId && answer.usage) {
         const now = await $.clock.now()
         if (answer.usage.model === await $.session.model()) {
@@ -1349,7 +1534,13 @@ export const register: Register = on => {
       const language = await read($, lang)
       if (e.agentId) {
         const now = await $.clock.now()
+        const before = (await read($, agents)).find(a => a.id === e.agentId)
         await update($, agents, list => list.map(a => a.id === e.agentId ? { ...a, state: e.reason === 'answer' ? 'done' : 'failed', endedAt: now, now: undefined, toolSince: undefined } : a))
+        // A picked worker's outcome, once, joined to its pick by id: whether the tier it was given
+        // (by the main chat or the judge) was enough is read from these lines later.
+        if (before?.pick?.id && (before.state === 'running' || before.state === 'waiting')) {
+          await persistWorkerPick($, { type: 'outcome', pick: before.pick.id, agent: e.agentId, at: new Date(now).toISOString(), reason: e.reason, aborted: e.isAborted, ms: e.durationMs, answerChars: e.answer.trim().length, model: before.model ?? null, cost: before.cost })
+        }
       } else if (!forking) {
         if (await read($, busy)) await update($, busy, () => false)
         const held = await read($, heldPick)
@@ -1388,18 +1579,22 @@ export const register: Register = on => {
         const files = await workerFiles($)
         try { await refreshModels($) } catch (error) { await report($, 'explicit worker catalogue', error) }
         const file = files.get(e.subagentType)
-        const provider = file ? agentProvider(file) : e.model && !/^(?:sonnet|opus|haiku|claude-)/.test(e.model) ? (await read($, routerModels)).find(m => m.value === e.model?.replace(/@[^@]*$/, ''))?.provider : 'anthropic'
+        const provider = file ? agentProvider(file) : e.model && !/^(?:sonnet|opus|haiku|fable|mythos|claude-)/.test(e.model) ? (await read($, routerModels)).find(m => m.value === e.model?.replace(/@[^@]*$/, ''))?.provider : 'anthropic'
         if (provider && s.providers[provider] === false) return { deny: t(await read($, lang), 'workers.disabled', { provider }) }
         const marker = readMarker(e.prompt)
-        if (marker) {
+        // A tier marker means something only to ripple:auto; on any other worker it is dropped
+        // rather than read as a model named "hard" (which the router would refuse).
+        if (tierOf(marker)) {
+          input = { ...e, prompt: e.prompt.replace(MARKER, '').replace(/^\s*\n/, '') }
+        } else if (marker) {
           const markerFile = files.get(marker.name) ?? [...files.values()].find(f => agentModel(f)?.replace(/@[^@]*$/, '') === marker.name)
           const markerProvider = markerFile ? agentProvider(markerFile) : (await read($, routerModels)).find(m => m.value === marker.name)?.provider
           if (markerProvider && s.providers[markerProvider] === false) return { deny: t(await read($, lang), 'workers.disabled', { provider: markerProvider }) }
         }
-        const fix = await workerFix($, e)
+        const fix = await workerFix($, input)
         if (fix) {
           if (fix.dropped) await $.ui.toast(t(await read($, lang), 'toasts.ownModel', { name: e.subagentType, model: fix.dropped }))
-          input = { ...e, prompt: fix.prompt, model: fix.model }
+          input = { ...input, prompt: fix.prompt, model: fix.model }
         }
       }
     } catch (error) { input = e; await report($, 'agent.spawn prepare', error) }
@@ -1415,7 +1610,9 @@ export const register: Register = on => {
     const result = await next(input)
     try {
       if (result.agentId) {
-        const rec: AgentRec = { id: result.agentId, description: input.description, type: input.subagentType, model: result.model, ...(chosen ? { pick: chosen } : {}), state: 'running', startedAt: await $.clock.now(), cost: 0 }
+        const provider = await spawnProvider($, input.subagentType, result.model)
+        const effort = chosen?.effort ?? /@([a-z]+)$/.exec(result.model)?.[1]
+        const rec: AgentRec = { id: result.agentId, description: input.description, type: input.subagentType, model: result.model, ...(chosen ? { pick: chosen } : {}), ...(provider ? { provider } : {}), ...(effort ? { effort } : {}), state: 'running', startedAt: await $.clock.now(), cost: 0 }
         await update($, agents, list => [...list.filter(a => a.id !== rec.id), rec].slice(-40))
       }
     } catch (error) { await report($, 'agent.spawn record', error) }
@@ -1425,7 +1622,8 @@ export const register: Register = on => {
     let started = 0
     try {
       started = await $.clock.now()
-      if (e.agentId) await update($, agents, list => list.map(a => a.id === e.agentId ? { ...a, now: toolLine(e), toolSince: started, state: 'running' } : a))
+      const line = e.agentId ? await toolLine($, e) : ''
+      if (e.agentId) await update($, agents, list => list.map(a => a.id === e.agentId ? { ...a, now: line, toolSince: started, state: 'running', tools: (a.tools ?? 0) + 1 } : a))
     } catch (error) { await report($, 'tool.call start', error) }
     try { return await next(e) }
     finally {
@@ -1494,7 +1692,11 @@ export const register: Register = on => {
     return next(e)
   })
   on('ui.close', { id: AGENTS_PANE }, async ($, e, next) => {
-    try { await update($, agentsOpen, () => false) } catch (error) { await report($, 'agents close', error) }
+    try {
+      await update($, agentsOpen, () => false)
+      // Opened again, the pane starts on the list.
+      if (await read($, agentOpen) !== null) await update($, agentOpen, () => null)
+    } catch (error) { await report($, 'agents close', error) }
     return next(e)
   })
   on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
@@ -1554,7 +1756,11 @@ export const register: Register = on => {
     try {
       startTimers($)
       const frame = await frameOf($, e)
-      return renderAgents($.ui.resolve(e), frame, { agents: await read($, agents), now: frame.now, showDone: await read($, agentsShowDone) }, { toggleDone: () => update($, agentsShowDone, value => !value) }) as RenderElement
+      // Read to be drawn again each second an agent runs (agentsClock): its elapsed time ticks.
+      await read($, agentsTick)
+      const id = await read($, agentOpen)
+      const open = id === null ? undefined : { id, talk: await agentTalk($, id), earlier: await read($, agentEarlier), runsOpen: await read($, agentRunsOpen) }
+      return renderAgents($.ui.resolve(e), frame, { agents: await read($, agents), now: frame.now, showDone: await read($, agentsShowDone), ...(open ? { open } : {}) }, agentsActions($)) as RenderElement
     } catch (error) { await report($, 'agents render', error); return next(e) }
   })
 }