clauderipple 0.9.4 → 0.10.0

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

@@ -2,7 +2,7 @@
 // callbacks it hands in. Every renderer in ./ is a pure function of (elements, view, actions);
 // none of them calls the engine, so they can be drawn and tested anywhere.
 
-import type { AgentRec, Effort, HandoffKind, JudgeKind, JudgeRun, LadderOptions, Pick, Settings, StatusRequest, TierTarget } from '../../types'
+import type { AgentRec, Effort, HandoffKind, JudgeKind, JudgeRun, LadderOptions, LimitItem, Pick, Settings, Skin, StatusRequest, TierTarget } from '../../types'
 import type { Appearance } from './theme'
 import { t } from '../i18n'
 import type { Lang } from '../i18n'
@@ -19,6 +19,8 @@ export type Frame = {
   /** Epoch ms when drawn; countdowns are computed from it. */
   now: number
   appearance: Appearance
+  /** The desktop's skin (look.ts); the terminal draws text whatever it is. */
+  skin: Skin
   lang: Lang
 }
 
@@ -69,6 +71,8 @@ export type DashboardView = {
   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
+  /** Every plan window for the second row, Claude's own first. Absent until read. */
+  limits?: LimitItem[]
   route: RouteView | null
   /** A line from the router side ("router not answering"), shown in place of the route. */
   notice: string | null
@@ -201,14 +205,37 @@ export type SetupActions = {
 
 // ---- Panes -----------------------------------------------------------------------------------
 
+/** One entry of an agent's conversation as the pane draws it (agents.tsx `talkOf`). */
+export type AgentEntry =
+  /** What it was asked: its first prompt, or a later message sent to it. */
+  | { kind: 'prompt'; text: string }
+  /** Its own words. */
+  | { kind: 'text'; text: string }
+  /** A tool it called: the tool, a short line of its input, and how it stands. */
+  | { kind: 'tool'; id: string; tool: string; detail: string; state: 'running' | 'ok' | 'error' }
+
+/** An agent's conversation as read (`$.session.messages({ agentId })`), or why it could not be. */
+export type AgentTalk = { entries: readonly AgentEntry[] } | { deny: string }
+
 export type AgentsView = {
   agents: readonly AgentRec[]
   now: number
+  /** Every finished agent, not only the latest few. */
   showDone: boolean
+  /** The agent whose conversation is open, what of it was read, and how many earlier pages show. */
+  open?: { id: string; talk: AgentTalk; earlier: number; runsOpen?: readonly string[] }
 }
 
 export type AgentsActions = {
   toggleDone: () => void
+  /** Opens an agent's conversation in the pane. */
+  open: (id: string) => void
+  /** Back to the list. */
+  back: () => void
+  /** One more page of the open conversation's earlier entries. */
+  earlier: () => void
+  /** Folds or unfolds a run of tool calls, named by its first call's id. */
+  toggleRun: (id: string) => void
 }
 
 export type LogView = {
@@ -242,10 +269,10 @@ export function effortLabel(value: string, lang: Lang): string {
 /** "claude-opus-5-5[1m]" → "Opus 5.5"; ids it does not know pass through, trimmed. */
 export function modelName(id: string): string {
   const bare = id.replace(/\[.*?\]/g, '').replace(/^claude-/, '')
-  const m = /^(opus|sonnet|haiku|fable)-(\d+)(?:-(\d{1,2}))?/.exec(bare)
+  const m = /^(opus|sonnet|haiku|fable|mythos)-(\d+)(?:-(\d{1,2}))?/.exec(bare)
   if (m) return m[1]!.charAt(0).toUpperCase() + m[1]!.slice(1) + ' ' + m[2] + (m[3] ? '.' + m[3] : '')
   // A bare alias ("sonnet") reads as its family's name.
-  if (/^(opus|sonnet|haiku|fable)\b/.test(bare) && !bare.includes('-')) return bare.charAt(0).toUpperCase() + bare.slice(1)
+  if (/^(opus|sonnet|haiku|fable|mythos)\b/.test(bare) && !bare.includes('-')) return bare.charAt(0).toUpperCase() + bare.slice(1)
   return bare
 }
 
@@ -377,3 +404,89 @@ export function limitName(kind: string, lang: Lang): string {
   if (kind === 'seven_day') return t(lang, 'band.weekly')
   return kind.replace(/_/g, ' ')
 }
+
+// ---- Limits row ----------------------------------------------------------------------------------
+
+/** A plan window's short name as the limits row shows it: the window, or the model's own name. */
+export function limitItemName(item: Pick<LimitItem, 'kind' | 'label' | 'windowMinutes'>, lang: Lang): string {
+  if (item.kind === 'five_hour' || item.kind === 'seven_day') return limitName(item.kind, lang)
+  if (item.kind === 'scoped') return item.label || item.kind
+  const minutes = item.windowMinutes
+  if (minutes === 300) return limitName('five_hour', lang)
+  if (minutes === 10080) return limitName('seven_day', lang)
+  if (typeof minutes === 'number' && minutes > 0) {
+    if (minutes % 1440 === 0) return t(lang, 'units.days', { n: minutes / 1440 })
+    if (minutes % 60 === 0) return t(lang, 'units.hours', { n: minutes / 60 })
+    return t(lang, 'units.minutes', { n: minutes })
+  }
+  return item.label || item.kind.replace(/_/g, ' ')
+}
+
+/** One limits group as the row heads it: a provider's own, or one of its accounts ("GPT", "GPT 1", …). */
+export type LimitGroup = { key: string; provider: string; type?: string; title?: string; account: number; items: LimitItem[] }
+
+/**
+ * The groups the row draws, one per provider account, Claude's plan first (the row keeps it to the
+ * last when narrow) and otherwise the router's answer order. Each window's item is unchanged.
+ */
+export function limitGroups(items: readonly LimitItem[]): LimitGroup[] {
+  const groups: LimitGroup[] = []
+  const index = new Map<string, LimitGroup>()
+  for (const item of items) {
+    const key = item.provider + '#' + item.account
+    let group = index.get(key)
+    if (!group) {
+      group = { key, provider: item.provider, ...(item.type ? { type: item.type } : {}), ...(item.title ? { title: item.title } : {}), account: item.account, items: [] }
+      index.set(key, group)
+      groups.push(group)
+    }
+    group.items.push(item)
+  }
+  // Claude's own plan comes first however the router ordered it; a stable sort keeps the rest.
+  const rank = (g: LimitGroup) => (g.type === 'anthropic' || g.provider === 'claude' ? 0 : 1)
+  return groups.sort((a, b) => rank(a) - rank(b))
+}
+
+/** The head's name when the item carries none: from its kind, else its config name. */
+function groupTitle(group: Pick<LimitGroup, 'provider' | 'type' | 'title'>): string {
+  if (group.title) return group.title
+  if (group.type === 'anthropic' || group.provider === 'claude') return 'Claude'
+  if (group.type === 'chatgpt' || group.provider === 'chatgpt') return 'GPT'
+  if (group.type === 'google') return 'Gemini'
+  return group.provider
+}
+
+/** A group's head: "Claude", "GPT", "Gemini", or its config name; "GPT 1"/"GPT 2" when numbered. */
+export function limitGroupName(group: Pick<LimitGroup, 'provider' | 'type' | 'title' | 'account'>, numbered: boolean): string {
+  const title = groupTitle(group)
+  return numbered ? title + ' ' + (group.account + 1) : title
+}
+
+/**
+ * The groups that fit `budget`, narrowing in this order: the scoped windows (Fable, 3P, …) go
+ * first, one group's at a time from the last group back, so Claude's own Fable is the last of them
+ * to go (all of them going at once hid Fable for Gemini's two 3P windows, 2026-10-15); then a later
+ * provider's secondary accounts (the last one first), then a later provider's whole group —
+ * Claude's own group (the first) stays to the last. Null when even that does not fit (no row).
+ * `width` measures a set of groups the way the row draws it.
+ */
+export function narrowLimitGroups(groups: readonly LimitGroup[], budget: number, width: (gs: readonly LimitGroup[]) => number): LimitGroup[] | null {
+  let out = [...groups]
+  for (let i = out.length - 1; i >= 0 && width(out) > budget; i--) {
+    if (!out[i]!.items.some(item => item.kind === 'scoped')) continue
+    out = out.map((g, j) => j === i ? { ...g, items: g.items.filter(item => item.kind !== 'scoped') } : g).filter(g => g.items.length > 0)
+  }
+  while (width(out) > budget && out.some(g => g.account > 0)) {
+    const at = out.map(g => g.account > 0).lastIndexOf(true)
+    out = out.filter((_, i) => i !== at)
+  }
+  while (width(out) > budget && out.length > 1) out = out.slice(0, -1)
+  if (!out.length || width(out) > budget) return null
+  return out
+}
+
+/** A window's hover tip: "Claude 주간 88% · 4시간 뒤 초기화". */
+export function limitItemTip(item: LimitItem, group: string, lang: Lang, now: number): string {
+  const reset = resetsLabel(item.resetsAt, now, lang)
+  return t(lang, 'band.limitsTip', { provider: group, window: limitItemName(item, lang), value: Math.round(item.percent) + '%', reset: reset ? ' · ' + reset : '' })
+}

package/dist/mod/hooks/workers.ts

@@ -7,11 +7,32 @@ import { kindOf, parseEffortVerdict, verdictObject } from './judge'
 import { claudeChoices, rungAbove, rungOf, tickedChoices } from './ladder'
 
 /** The one agent the main chat delegates to; the judge picks the worker (docs/specs/2026-10-12-worker-tiers.md). */
-export const AUTO_DESCRIPTION = 'Delegate any task here; ClaudeRipple judges how hard it is (low/medium/high/max) and picks the model. If a worker fails or returns nothing usable, delegate again here once and say the earlier attempt failed.'
+export const AUTO_DESCRIPTION = 'Delegate any task here; ClaudeRipple picks the model. If a worker fails or returns nothing usable, delegate again here once and say the earlier attempt failed. ' +
+  'If you know how hard the task is, put [[ripple: light]], [[ripple: standard]], [[ripple: hard]] or [[ripple: max]] on the prompt\'s first line: ' +
+  'light = lookups, mechanical edits, one small fix; standard = carry out a designed change (even across several files), research, summarize, read-only review; ' +
+  'hard = subtle debugging, security review, or work where a wrong call is costly; max = planning, design or architecture where the deliverable is the decision itself. ' +
+  'Size, file count or the brief\'s warnings do not by themselves make a task hard. Leave the marker out when unsure, and ClaudeRipple judges it.'
+
+/**
+ * The tier markers the main chat may write on a ripple:auto prompt, as the judge's verdict they
+ * stand for (`rungOf` gives light, standard, hard, plan). The main chat knows the whole
+ * conversation, the judge one brief: re-judging 62 delegations (2026-10-15), the judge sent 32 to
+ * hard, Opus under this description 18. Not model names, so never routed as one.
+ */
+export const TIER_MARKERS: Readonly<Record<string, Pick<WorkerVerdict, 'level' | 'kind'>>> = {
+  light: { level: 'light', kind: 'do' },
+  standard: { level: 'standard', kind: 'do' },
+  hard: { level: 'deep', kind: 'do' },
+  max: { level: 'deep', kind: 'plan' },
+}
+/** The tier a marker names, if it is one. */
+export function tierOf(marker: { name: string } | null): string | null {
+  return marker && Object.hasOwn(TIER_MARKERS, marker.name) ? marker.name : null
+}
 
 export const WORKER_JUDGE_SYSTEM = `Choose a domain, capability level, kind of work and the cheapest effort that still does this delegated task well. Evaluate actual scope and risk, not prompt length.
 Domains: design (visual taste, composition, brand), frontend (UI implementation), backend (APIs and server logic), infra (deployment and operations), data (queries and processing), test (verification), docs (writing), research (investigation), general (other or cross-domain).
-Levels are independent of domain: light (chores, mechanical work, simple lookups), standard (designed implementation, ordinary research and review), deep (careful high-stakes reasoning, subtle bugs, architecture, security). A task that says an earlier attempt failed is one level higher than it would otherwise be.
+Levels are independent of domain: light (chores, repeated edits, simple lookups, one small fix), standard (carry out a designed change, even across several files; research, summarize, read-only review), deep (subtle debugging, security review, or architecture where a wrong call is costly; size, file count, or warnings and prohibitions in the brief do not by themselves make work deep). A task that says an earlier attempt failed is one level higher than it would otherwise be.
 Kind is determined by the deliverable, not preparatory steps. plan = pure planning: the deliverable is a decision, design, specification, or review verdict, NOT implemented code. do = carry out work: implement, fix, run, look up, write. Any task whose deliverable includes implemented code, files, builds or fixes is do, even if it says "read the spec/design first" or requires architecture/design reasoning before implementation. Writing a design/spec document alone remains plan; producing implementation files is do. Examples: "implement host listing of sessions" => do; "build an iOS app" => do; "read the spec first, then implement it" => do; "decide the session-listing architecture; do not implement" => plan. If planning and implementation are mixed, choose do. Deep plan is the hardest work, which runs on the strongest model, reserved for pure architecture, system design or consequential design decisions.
 Effort choices are low, medium, high, xhigh, max; reserve the last two for exceptionally hard work. Return only JSON {"domain":"design|frontend|backend|infra|data|test|docs|research|general","level":"light|standard|deep","kind":"plan|do","effort":"low|medium|high|xhigh|max","sure":0.0,"why":"brief reason"}. Confidence is zero to one and is about the level; explain in the user's language in at most six words.`
 
@@ -192,12 +213,13 @@ const TITLE_PREFIX = /^[^\s·]+(?:·[a-z]+)? · /
  */
 export function titleName(model: string, models: readonly RouterModel[] = []): string {
   const id = baseModel(model).replace(/\[.*?\]/g, '')
-  const claude = /^(?:claude-)?(opus|sonnet|haiku|fable)(?:-(\d+)(?:-(\d{1,2}))?)?/i.exec(id)
+  const claude = /^(?:claude-)?(opus|sonnet|haiku|fable|mythos)(?:-(\d+)(?:-(\d{1,2}))?)?/i.exec(id)
   if (claude) return claude[1]!.charAt(0).toUpperCase() + claude[1]!.slice(1).toLowerCase() + (claude[2] ? claude[2] + (claude[3] ? '.' + claude[3] : '') : '')
+  // A hosted id's vendor path ("deepseek-ai/") is dropped: the title has room for the model only.
   const named = models.find(m => m.value.toLowerCase() === id.toLowerCase())?.name
-  if (named) return named.trim().split(/\s+/).pop()!
+  if (named) return named.trim().split(/\s+/).pop()!.replace(/^.*\//, '')
   const gpt = /^gpt-[\d.]+-([a-z]+)$/i.exec(id)
-  return gpt ? gpt[1]!.charAt(0).toUpperCase() + gpt[1]!.slice(1) : id
+  return gpt ? gpt[1]!.charAt(0).toUpperCase() + gpt[1]!.slice(1) : id.replace(/^.*\//, '')
 }
 
 /**
@@ -207,8 +229,13 @@ export function titleName(model: string, models: readonly RouterModel[] = []): s
  */
 export function spawnTitle(description: string, model: string, effort: string | undefined, models: readonly RouterModel[] = []): string {
   const tag = titleName(model, models) + (effort ? '·' + effort : '')
+  return `${tag} · ${bareTitle(description)}`
+}
+
+/** A title without the model tag spawnTitle put in front ("Sol·high · Port it" → "Port it"). */
+export function bareTitle(description: string): string {
   const bare = description.replace(TITLE_PREFIX, '')
-  return `${tag} · ${bare.trim() ? bare : description}`
+  return bare.trim() ? bare : description
 }
 
 export function takesOver(spawn: { subagentType: string; model?: string; fork: boolean }, settings: Settings): boolean {

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

@@ -4,7 +4,7 @@ import type { Engine } from 'claude-code/testing'
 import type { AgentSpawnInput, ModelCompleteRequest, ModelUsage, On, SessionMessage, ToolCallInput, TurnStepInput } from 'claude-code'
 import { MOD_SETTINGS_SCHEMA_VERSION, DEFAULTS, normalizeModes, normalizeSettings } from '../hooks/settings'
 import type { Lang } from '../hooks/i18n'
-import type { ModSettingsSnapshot, Settings } from '../types'
+import type { AgentRec, ModSettingsSnapshot, Settings } from '../types'
 
 const NOW = 1000000
 const USAGE: ModelUsage = { input_tokens: 100, output_tokens: 10, cache_read_input_tokens: 40000, cache_creation_input_tokens: 0 }
@@ -34,7 +34,7 @@ const CONFIG = { admin: { port: 9992 }, providers: { deepseek: { models: [{ id:
 const SPAWN: AgentSpawnInput = { tool_use_id: 'tool1', subagentType: 'ripple:auto', prompt: 'Rename one local variable and verify it.', description: 'Rename variable', parentModel: 'claude-opus-5-5', provider: { plugin: 'engine', tier: 'core' }, background: false, fork: false }
 const MESSAGES: SessionMessage[] = [{ role: 'user', text: 'Implement the specified change and verify it.', toolUses: [] }, { role: 'assistant', text: 'The implementation is ready.', toolUses: [] }]
 
-function boundaries(on: On, patch: Partial<Settings> = {}, options: { config?: unknown; paths?: string[]; key?: string; envFile?: string | (() => string); language?: unknown; env?: Record<string, string>; platform?: string; browserFailure?: 'exit' | 'throw'; appleLocale?: string; appleFail?: boolean; limits?: { kind: string; percentUsed: number; resetsAt?: string }[] } = {}) {
+function boundaries(on: On, patch: Partial<Settings> = {}, options: { config?: unknown; paths?: string[]; key?: string; envFile?: string | (() => string); language?: unknown; env?: Record<string, string>; platform?: string; browserFailure?: 'exit' | 'throw'; appleLocale?: string; appleFail?: boolean; limits?: { kind: string; percentUsed: number; resetsAt?: string }[]; agentMessages?: (agentId: string) => SessionMessage[] } = {}) {
   const clock = mock.clock(on, { now: NOW })
   const saved = new Map<string, unknown>()
   const storeWrites: string[] = []
@@ -116,7 +116,7 @@ function boundaries(on: On, patch: Partial<Settings> = {}, options: { config?: u
   on('command.list', () => ({ value: [{ name: 'clear', description: 'Clear', source: 'builtin' }, { name: 'compact', description: 'Compact', source: 'builtin' }, { name: 'model', description: 'Model', source: 'builtin' }] }))
   on('session.id', () => ({ value: 'session-test' }))
   on('session.model', () => ({ value: model }))
-  on('session.messages', () => ({ value: MESSAGES }))
+  on('session.messages', ($, e) => ({ value: e.agentId && options.agentMessages ? options.agentMessages(e.agentId) : MESSAGES }))
   on('session.usage', () => ({ value: { startedAt: NOW, context: { percent, tokens: 40000, window: 200000 }, rateLimits: options.limits ?? [] } }))
   on('ui.status', () => ({ value: undefined }))
   on('ui.toast', ($, e) => { toasts.push(e.text); return { value: undefined } })
@@ -500,27 +500,29 @@ test('ripple:auto is judged and rewritten to the light rung\'s agent at the rung
   const persisted = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!
   expect(persisted.endsWith('\n')).toBe(true)
   expect(persisted.trim().split('\n').length).toBe(1)
-  expect(JSON.parse(persisted)).toEqual({
+  const row = JSON.parse(persisted)
+  expect(typeof row.id).toBe('string')
+  expect(row).toEqual({
     ...JSON.parse(b.logs[0]!.slice('ClaudeRipple worker pick: '.length)),
-    at: new Date(NOW).toISOString(), by: 'judge', judge: 'haiku', ms: 0,
+    type: 'pick', id: row.id, at: new Date(NOW).toISOString(), by: 'judge', judge: 'haiku', ms: 0, promptChars: SPAWN.prompt.length,
     verdict: { domain: 'general', level: 'light', kind: 'do', effort: 'low', sure: 0.9, why: 'small rename' },
   })
   const stats = await $.command.run({ command: 'ripple', origin: { kind: 'composer' }, presentation: { isFullscreen: true, columns: 140 }, args: 'stats' })
   expect(stats.text).toContain('light 1')
 })
 
-test('worker pick persistence keeps the last 300 lines and concurrent marker picks, never the prompt', async ($, on) => {
+test('worker pick persistence keeps the last 3,000 lines and concurrent marker picks, never the prompt', async ($, on) => {
   const b = boundaries(on, {}, { env: { CLAUDERIPPLE_HOME: '/custom/ripple' } })
   http(on)
   const judges = judgeStub(on)
   spawnStub(on)
   const path = '/custom/ripple/logs/worker-picks.jsonl'
-  b.files.set(path, Array.from({ length: 305 }, (_, n) => JSON.stringify({ old: n })).join('\n') + '\n')
+  b.files.set(path, Array.from({ length: 3005 }, (_, n) => JSON.stringify({ old: n })).join('\n') + '\n')
   await start($)
   await Promise.all(['first', 'second'].map(label => $.agent.spawn({ ...SPAWN, description: label + 'x'.repeat(220), prompt: '[[ripple: gpt-6-1-sol@xhigh]]\nPRIVATE_TASK_PROMPT' })))
   const text = b.files.get(path)!
   const rows = text.trim().split('\n').map(line => JSON.parse(line))
-  expect(rows.length).toBe(300)
+  expect(rows.length).toBe(3000)
   expect(rows[0]).toEqual({ old: 7 })
   expect(rows.slice(-2).map(row => row.task).sort()).toEqual(['first' + 'x'.repeat(195), 'second' + 'x'.repeat(194)])
   for (const row of rows.slice(-2)) expect(row).toMatchObject({ by: 'marker', verdict: null, judge: null, ms: 0, model: 'gpt-6.1-sol@xhigh', effort: 'xhigh' })
@@ -588,6 +590,69 @@ for (const prefix of ['ripple:', '']) for (const [level, kind, rung, agent, mode
   }
 })
 
+// The main chat may name the tier itself; the judge then only rates it in the shadow (2026-10-15).
+for (const [tier, rung, agent, model] of [
+  ['light', 'light', 'deepseek-v4-1-flash', 'deepseek-v4.1-flash@max'],
+  ['standard', 'standard', 'gpt-6-1-sol', 'gpt-6.1-sol@medium'],
+  ['hard', 'hard', 'gpt-6-astra', 'gpt-6-astra@high'],
+  ['max', 'plan', 'general-purpose', 'opus'],
+] as const) test(`a [[ripple: ${tier}]] marker runs the ${rung} rung, the judge rating it only in the log`, async ($, on) => {
+  const b = boundaries(on)
+  http(on)
+  const judges = judgeStub(on, JSON.stringify({ domain: 'backend', level: 'deep', kind: 'do', effort: 'high', sure: 0.8, why: 'judged' }))
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn({ ...SPAWN, prompt: `[[ripple: ${tier}]]\nRename one local variable and verify it.` })
+  await b.clock.settle()
+  // The tier marker is the main chat's to the mod, never a model name the router would see.
+  expect(sent[0]).toMatchObject({ subagentType: agent, model, prompt: 'Rename one local variable and verify it.' })
+  const rows = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').map(line => JSON.parse(line))
+  const pick = rows.find(row => row.type === 'pick')
+  expect(pick).toMatchObject({ by: 'session', tier, rung, judge: null, verdict: null })
+  // The judge still rated the same brief, beside the pick, without holding the spawn.
+  expect(judges.length).toBe(1)
+  expect(rows.find(row => row.type === 'shadow')).toMatchObject({ pick: pick.id, rung: 'hard', judge: 'haiku', verdict: { level: 'deep', kind: 'do' } })
+  // The worker's end joins the same pick.
+  await complete($, 'worker-1', 'Renamed and tested.')
+  const after = b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').map(line => JSON.parse(line))
+  expect(after.find(row => row.type === 'outcome')).toMatchObject({ pick: pick.id, agent: 'worker-1', reason: 'answer', aborted: false, ms: 1000, answerChars: 19 })
+  // Once: a second completion of the same agent writes no second outcome.
+  await complete($, 'worker-1')
+  expect(b.files.get('/home/test/.clauderipple/logs/worker-picks.jsonl')!.trim().split('\n').filter(line => line.includes('"outcome"')).length).toBe(1)
+})
+
+test('the limits row shows Claude\'s plan on a chat that runs on another provider', async ($, on) => {
+  const b = boundaries(on, { extras: ['limits'] })
+  b.setModel('muse-spark-1.3-contributor')
+  // The unified `/api/limits` body: Claude's plan regardless of the chat's routed provider.
+  const limits = { providers: [{ provider: 'claude', type: 'anthropic', title: 'Claude', accounts: [{ account: 0, at: NOW, windows: [
+    { kind: 'five_hour', used_percent: 1, window_minutes: 300, reset_at: (NOW + 3_600_000) / 1000 },
+    { kind: 'seven_day', used_percent: 88, window_minutes: 10080, reset_at: (NOW + 7_200_000) / 1000 },
+    { kind: 'scoped', label: 'Fable', used_percent: 2, window_minutes: 10080 },
+  ] }] }] }
+  on('http.fetch', ($, e, next) => {
+    if (e.url.endsWith('/api/mod-settings')) return next(e)
+    return { value: { ok: true, status: 200, headers: {}, text: JSON.stringify(e.url.endsWith('/api/limits') ? limits : { requests: [] }) } }
+  })
+  await start($)
+  await b.clock.advance(15000)
+  const ui = await band($, 'desktop')
+  for (const text of [/^Claude$/, /^88%$/, /^Fable$/]) expect(await ui.find({ type: 'Text', text }), String(text)).toBeDefined()
+  await ui.unmount()
+})
+
+test('a tier marker on a worker other than ripple:auto is dropped, not routed as a model', async ($, on) => {
+  boundaries(on)
+  http(on)
+  const judges = judgeStub(on)
+  const sent = spawnStub(on)
+  await start($)
+  await $.agent.spawn({ ...SPAWN, subagentType: 'Explore', prompt: '[[ripple: hard]]\nFind the router entry point.' })
+  expect(judges.length).toBe(0)
+  expect(sent[0]).toMatchObject({ subagentType: 'Explore', prompt: 'Find the router entry point.' })
+  expect(sent[0]?.model).toBeUndefined()
+})
+
 test('a judged spawn uses the default general ladder when general is inherit', async ($, on) => {
   boundaries(on, { rules: normalizeSettings({ rules: { general: { mode: 'inherit' } } }).rules })
   http(on)
@@ -648,7 +713,7 @@ for (const agentAuto of ['off', 'auto', 'all'] as const) test('only ripple:auto
   await start($)
   expect([...new Set(registered.map(e => e.name))]).toEqual(agentAuto === 'off' ? [] : ['auto'])
   for (const entry of registered) {
-    expect(entry.description).toContain('low/medium/high/max')
+    expect(entry.description).toContain('[[ripple: standard]]')
     expect(entry.disallowedTools).toEqual(['Agent'])
   }
   await $.agent.spawn(SPAWN)
@@ -1449,9 +1514,88 @@ test('known agents show waiting after an eight-second tool and finish with cost'
   await b.clock.advance(15000)
   await tool
   await complete($, 'worker-1')
-  await ui.press({ key: 'done' })
   expect(await ui.find({ type: 'Text', text: 'Rename variable' })).toBeDefined()
-  expect(await ui.find({ type: 'Text', text: /≈4/ })).toBeDefined()
+  // The API's own counts (100 + 40000 cached in, 10 out), not the weighted cost.
+  expect(await ui.find({ type: 'Text', text: 'in 40k · cache 100% · out 10 · tools 1' })).toBeDefined()
+})
+
+test('an agent keeps the API\'s token counts, its tools and the effort it was sent at; its card opens its conversation and goes back', async ($, on) => {
+  const reads: string[] = []
+  boundaries(on, {}, { agentMessages: id => {
+    reads.push(id)
+    return [{ role: 'user', text: 'Rename one local variable and verify it.', toolUses: [] }, { role: 'assistant', text: 'Renamed it.', toolUses: [{ tool_use_id: 't1', tool: 'Bash', input: { command: 'npm test' }, text: 'ok' }] }]
+  } })
+  http(on)
+  judgeStub(on)
+  spawnStub(on)
+  stepStub(on, { input_tokens: 300, output_tokens: 50, cache_read_input_tokens: 9000, cache_creation_input_tokens: 700 })
+  on('tool.call', () => ({ result: 'ok' }))
+  let written: AgentRec[] = []
+  on('state.set', { plugin: 'ripple', key: 'agents' }, async ($, e, next) => {
+    const result = await next(e)
+    written = e.value as AgentRec[]
+    return result
+  })
+  await start($)
+  await $.agent.spawn(SPAWN)
+  // The routed id's @low is what the router sends, whatever the request's own effort says.
+  await step($, 'deepseek-v4.1-flash@low', 'high', 'worker-1')
+  await step($, 'deepseek-v4.1-flash@low', 'high', 'worker-1')
+  const input: ToolCallInput = { tool: 'Bash', command: 'npm test', agentId: 'worker-1', tool_use_id: 'tool-a' }
+  await $.tool.call(input)
+  const rec = written.find(a => a.id === 'worker-1')
+  expect(rec?.usage).toEqual({ input: 600, cached: 18_000, cacheWrite: 1400, output: 100 })
+  expect(rec?.tools).toBe(1)
+  expect(rec?.effort).toBe('low')
+  expect(rec?.answeredBy).toBe('deepseek-v4.1-flash@low')
+  expect(rec?.provider).toBe('deepseek')
+  const ui = await $.ui.mount({ plugin: 'ripple', component: 'Pane', requestId: 'ripple-agents', surface: 'terminal', props: { title: 'Agents', isFocused: true, bodyColumns: 100, placement: 'inline', scroll: { offset: 0, bodyRows: 30 }, view: {} } })
+  expect(await ui.find({ type: 'Text', text: /in 20k · cache 90% · out 100 · tools 1/ })).toBeDefined()
+  expect(reads).toEqual([])
+  await ui.press({ key: 'open-worker-1' })
+  expect(reads).toContain('worker-1')
+  expect(await ui.find({ type: 'Text', text: 'Renamed it.' })).toBeDefined()
+  expect(await ui.find({ type: 'Text', text: 'npm test' })).toBeDefined()
+  await ui.press({ key: 'back' })
+  expect(await ui.find({ type: 'Text', text: 'Renamed it.' })).toBeUndefined()
+  expect(await ui.find({ type: 'Button', key: 'open-worker-1' })).toBeDefined()
+})
+
+test('an agent\'s run of tool calls unfolds on press, its paths short against the session folder, and folds again once the pane goes back', async ($, on) => {
+  boundaries(on, {}, { agentMessages: () => [
+    { role: 'user', text: 'Run the tests.', toolUses: [] },
+    { role: 'assistant', text: 'Running.', toolUses: [
+      { tool_use_id: 'c1', tool: 'Bash', input: { command: 'cd /work/android && ./gradlew test' }, text: 'ok' },
+      { tool_use_id: 'c2', tool: 'Read', input: { file_path: '/work/core/A.kt' }, text: 'ok' },
+    ] },
+  ] })
+  http(on)
+  judgeStub(on)
+  spawnStub(on)
+  stepStub(on)
+  const runs: unknown[] = []
+  on('state.set', { plugin: 'ripple', key: 'agentRunsOpen' }, async ($, e, next) => {
+    runs.push(e.value)
+    return next(e)
+  })
+  await start($)
+  await $.agent.spawn(SPAWN)
+  const ui = await $.ui.mount({ plugin: 'ripple', component: 'Pane', requestId: 'ripple-agents', surface: 'terminal', props: { title: 'Agents', isFocused: true, bodyColumns: 100, placement: 'inline', scroll: { offset: 0, bodyRows: 30 }, view: {} } })
+  await ui.press({ key: 'open-worker-1' })
+  expect(await ui.find({ type: 'Button', text: /^Ran 1 command, Read 1 file/ })).toBeDefined()
+  expect(await ui.find({ type: 'Text', text: './gradlew test' })).toBeUndefined()
+  await ui.press({ key: 'run-c1' })
+  expect(await ui.find({ type: 'Text', text: /^\.\/gradlew test$/ })).toBeDefined()
+  expect(await ui.find({ type: 'Text', text: /^core\/A\.kt$/ })).toBeDefined()
+  await ui.press({ key: 'run-c1' })
+  expect(await ui.find({ type: 'Text', text: './gradlew test' })).toBeUndefined()
+  await ui.press({ key: 'run-c1' })
+  expect(runs.at(-1)).toEqual(['c1'])
+  await ui.press({ key: 'back' })
+  // Back on the list, the unfolded run is forgotten.
+  expect(runs.at(-1)).toEqual([])
+  await ui.press({ key: 'open-worker-1' })
+  expect(await ui.find({ type: 'Text', text: './gradlew test' })).toBeUndefined()
 })
 
 /** The claude:// link a handoff opened, and its query. */