clauderipple 0.9.3 → 0.9.4

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

@@ -22,7 +22,7 @@ import { rippleSource } from './parts'
 import type { Els } from './parts'
 import type { Face } from './ripple'
 import type { Frame } from './view'
-import { CELL_PX, CLOSE_PX, INK, ROW_PX, SUB, SWITCH_H, SWITCH_W, WELL_PX, closeArt, labelPx, pillArt, seaArt, segmentedArt, sliderArt, switchArt, wellArt } from './art'
+import { CELL_PX, CLOSE_PX, INK, ROW_PX, SUB, SWITCH_H, SWITCH_W, WELL_PX, closeArt, extraHoverArt, labelPx, pillArt, seaArt, segmentedArt, sliderArt, switchArt, wellArt, wordArt } from './art'
 import type { Glyph, PillLook, Sea, Tone } from './art'
 import { chOf } from './theme'
 
@@ -35,7 +35,7 @@ const EDGE = 'rgba(128,124,116,0.55)'
 /** A control under the pointer: a soft light on the water. */
 const HOVER = 'rgba(255,255,255,0.09)'
 const HOVER_EDGE = 'rgba(255,255,255,0.16)'
-/** A drawn control's height, px: pills, segments. */
+/** A drawn control's height, px: pills, segments (art.ts holds the same figure). */
 const CONTROL_PX = 26
 
 /** Cells a run of px takes, rounded up. */
@@ -116,6 +116,14 @@ export function lit(el: Els, key: string, cells: number, children: RenderNode[],
   )
 }
 
+/** The drawn light over `cells`, in absolute Boxes of whole cells each. */
+function extraHover(el: Els, cells: number): RenderNode[] {
+  const { Box } = el
+  const parts: RenderNode[] = []
+  for (let i = 0; i < cells; i++) parts.push(<Box key={'extra-' + i} position="absolute" top={0} bottom={0} left={i} width={1}>{pic(el, 'extra-' + i, extraHoverArt(CELL_PX), '', CELL_PX, CONTROL_PX)}</Box>)
+  return parts
+}
+
 /**
  * A capsule: a rounded Box edged in violet light, the deep (art.ts `seaArt`) painted behind it from
  * its top left, and everything it holds in one positioned layer above the sea. `rows` is about how
@@ -184,6 +192,30 @@ export function toggleCells(label: string): number {
   return Math.ceil((SWITCH_W + CELL_PX + chOf(label) * CELL_PX * 1.1) / CELL_PX) + 1
 }
 
+/** Cells the Auto word takes as its own control: its picture's width (the pill's own air drawn in). */
+export function wordCells(label: string): number {
+  return wordArt(label, true).cells
+}
+
+/**
+ * The Auto word as the control itself (art.ts `wordArt`): lit violet while Auto is on, a quiet
+ * ghost while off, pulsing while the judge decides; the whole pressable.
+ */
+export function word(el: Els, key: string, on: boolean, label: string, onPress: () => void, busy = false, scope?: string): RenderNode {
+  const { Box } = el
+  const art = wordArt(label, on, busy)
+  return (
+    <Box key={(on ? 'word-on-' : 'ghost-') + key} position="relative" width={art.cells} height={rowsOf(CONTROL_PX)} flexShrink={0} alignItems="center" justifyContent="center">
+      {pic(el, key, art.source, label, art.cells * CELL_PX, CONTROL_PX)}
+      <Box position="absolute" top={0} bottom={0} left={0} right={0} display="none" hover={{ scope }}>
+        {lift(el)}
+        {extraHover(el, art.cells)}
+      </Box>
+      {press(el, key, art.cells * CELL_PX, onPress)}
+    </Box>
+  )
+}
+
 /** A switch and its word (On / Off), the whole pressable; lit while on. */
 export function toggle(el: Els, key: string, on: boolean, label: string, onPress: () => void, busy = false, scope?: string): RenderNode {
   const { Text } = el

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

@@ -95,6 +95,7 @@ export type BandActions = {
   toggleAuto: () => void
   toggleWarm: () => void
   compact: () => void
+  clear: () => void
   handoff: () => void
   toggleLog: () => void
   toggleAgents: () => void
@@ -125,11 +126,15 @@ export type AlertView =
   | { kind: 'result'; stage: ResultStage; handoffKind?: HandoffKind; detail?: string }
   /** Compact with an optional note of what to keep. */
   | { kind: 'compactNote'; draft: string }
+  /** The band's Clear asks before the conversation is started over. */
+  | { kind: 'clear' }
   /** Quick or full handoff, and what happens after. */
   | { kind: 'handoffChoice'; handoffKind: HandoffKind; after: Settings['handoffAfter'] }
 
 export type AlertActions = {
   compact: (note?: string) => void
+  /** Runs the conversation's clear, from the Clear confirm card. */
+  clear: () => void
   /** Opens the handoff choice bar. */
   handoff: () => void
   dismiss: () => void

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

@@ -1753,14 +1753,16 @@ test('every band control changes the next drawing, and a toggle says its state o
   http(on)
   await start($)
   await b.clock.advance(3000)
-  // The terminal says it in the label (● / ○); the desktop in the control's drawing: a switch's lit
-  // track, a lit icon, each picture marked `on` or `off` at its root.
+  // The terminal says it in the label (● / ○); the desktop in the control's drawing: a lit icon,
+  // a lit word, each picture marked `on` or `off` at its root.
   const desktopState = (n: unknown) => {
     const drawing = JSON.stringify(n ?? '')
     return /<svg[^>]* class=\\"on\\"/.test(drawing) ? 'on' : /<svg[^>]* class=\\"off\\"/.test(drawing) ? 'off' : 'other'
   }
   const state = async (ui: Awaited<ReturnType<typeof band>>, key: string, surface: string) =>
-    surface === 'desktop' ? desktopState(await ui.find({ type: 'Box', key: 'hv-' + key })) : (n => /●/.test(String(n?.props.label)) ? 'on' : /○/.test(String(n?.props.label)) ? 'off' : 'other')(await ui.find({ type: 'Button', key }))
+    surface === 'desktop'
+      ? desktopState(await ui.find({ type: 'Box', key: key === 'auto' ? 'word-on-auto' : 'hv-' + key }) ?? await ui.find({ type: 'Box', key: 'ghost-' + key }))
+      : (n => /●/.test(String(n?.props.label)) ? 'on' : /○/.test(String(n?.props.label)) ? 'off' : 'other')(await ui.find({ type: 'Button', key }))
   for (const surface of ['terminal', 'desktop'] as const) {
     const ui = await band($, surface)
     const drawn = async () => JSON.stringify(await ui.drawn()).replace(/"handle":\d+/g, '')
@@ -1791,3 +1793,29 @@ test('every band control changes the next drawing, and a toggle says its state o
     await ui.unmount()
   }
 })
+
+// 2026-10-14: the band's Clear icon asks before it runs /clear; Cancel leaves the chat alone.
+test('the band Clear asks first, and confirming runs the clear once', async ($, on) => {
+  const b = boundaries(on)
+  http(on)
+  const commands: string[] = []
+  on('command.run', { command: 'clear' }, () => { commands.push('clear'); return {} })
+  await start($)
+  const ui = await band($, 'desktop')
+  expect(await ui.find({ key: 'clear' })).toBeDefined()
+  await ui.press({ key: 'clear' })
+  expect(commands).toEqual([])
+  expect(await ui.find({ type: 'Text', text: 'Start this conversation over?' })).toBeDefined()
+  expect(await ui.find({ type: 'Text', text: /context is emptied/ })).toBeDefined()
+  // Cancel keeps the conversation and closes the card.
+  await ui.press({ key: 'dismiss' })
+  expect(commands).toEqual([])
+  expect(await ui.find({ type: 'Text', text: 'Start this conversation over?' })).toBeUndefined()
+  // The main action runs the clear once.
+  await ui.press({ key: 'clear' })
+  await ui.press({ key: 'clear-go' })
+  await b.clock.advance(3000)
+  expect(commands).toEqual(['clear'])
+  expect(await ui.find({ type: 'Text', text: 'Start this conversation over?' })).toBeUndefined()
+  await ui.unmount()
+})

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

@@ -143,7 +143,7 @@ test('view helpers', () => {
 test('the band draws on both surfaces and its controls reach their callbacks', async ($, on) => {
   const { calls, fn } = recorder()
   const actions = {
-    toggleAuto: fn('auto'), toggleWarm: fn('warm'), compact: fn('compact'), handoff: fn('handoff'), toggleLog: fn('log'),
+    toggleAuto: fn('auto'), toggleWarm: fn("warm"), compact: fn("compact"), clear: fn("clear"), handoff: fn("handoff"), toggleLog: fn('log'),
     toggleAgents: fn('agents'), openSettings: fn('settings'), toggleEffortMenu: fn('menu'), pickEffort: fn('pick'),
   }
   drawPane(on, 'band', (el, surface) => renderBand(el, frameOf(surface), DASH, actions))
@@ -152,10 +152,11 @@ test('the band draws on both surfaces and its controls reach their callbacks', a
   )
   for (const surface of SURFACES) {
     const ui = await mount($, 'band', surface)
-    // Compact left the band (it is /compact and the alerts' choice).
-    expect(await ui.find({ key: 'compact' })).toBeUndefined()
-    // The desktop's Log is the route itself.
-    for (const key of surface === 'terminal' ? ['auto', 'warm', 'log', 'agents', 'settings'] : ['auto', 'warm', 'agents', 'settings']) {
+    // Compact and clear are the desktop's icons; the terminal has no Log (the route is its own press)…
+    const keys = surface === 'terminal' ? ['auto', 'warm', 'log', 'agents', 'settings'] : ['auto', 'warm', 'agents', 'compact', 'clear', 'settings']
+    // …but no Compact clear card here: the desktop's Compact opens the note bar from the band.
+    if (surface === 'terminal') expect(await ui.find({ key: 'compact' })).toBeUndefined()
+    for (const key of keys) {
       expect(await ui.find({ type: 'Button', key }), "ui { type: 'Button', key } " + surface).toBeDefined()
       await ui.press({ key })
     }
@@ -185,7 +186,6 @@ test('the band draws on both surfaces and its controls reach their callbacks', a
 
     const busy = await mount($, 'band-busy', surface)
     expect(await busy.find({ key: 'handoff' }), "busy { key: 'handoff' } " + surface).toBeDefined()
-    expect(await busy.find({ key: 'compact' })).toBeUndefined()
     await busy.press({ key: 'handoff' })
     await busy.press({ key: 'pick-low' })
     if (surface === 'desktop') {
@@ -200,6 +200,8 @@ test('the band draws on both surfaces and its controls reach their callbacks', a
   }
   expect(calls.filter(c => c === 'auto').length).toBe(2)
   expect(calls.filter(c => c === 'log').length).toBe(2)
+  expect(calls.filter(c => c === 'compact').length).toBe(1)
+  expect(calls.filter(c => c === 'clear').length).toBe(1)
   expect(calls.filter(c => c === 'menu').length).toBe(1)
   expect(calls.filter(c => c === 'pick:["low"]').length).toBe(2)
   expect(calls.filter(c => c === 'handoff').length).toBe(2)
@@ -207,7 +209,7 @@ test('the band draws on both surfaces and its controls reach their callbacks', a
 
 test('the band draws the same markup for the same view', async ($, on) => {
   const noop = () => undefined
-  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
+  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, clear: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
   drawPane(on, 'band', (el, surface) => renderBand(el, frameOf(surface), { ...DASH, effort: { level: 'medium', mode: 'deciding', since: NOW - 300 } }, actions))
   const once = await mount($, 'band', 'desktop')
   const first = JSON.stringify(await once.drawn())
@@ -218,7 +220,7 @@ test('the band draws the same markup for the same view', async ($, on) => {
 
 test('the terminal band fits its rows at narrow widths', async ($, on) => {
   const noop = () => undefined
-  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
+  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, clear: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
   const busy: DashboardView = { ...DASH, warm: { on: true, pings: 3, cost: 0 }, limit: { kind: 'seven_day', percent: 91, save: false } }
   drawPane(on, 'wide', el => renderBand(el, frameOf('terminal', 200, 3), busy, actions))
   drawPane(on, 'narrow', el => renderBand(el, frameOf('terminal', 60, 4), busy, actions))
@@ -242,7 +244,7 @@ test('the minimal footer draws on both surfaces', async ($, on) => {
 test('a ko frame resolves temporary Korean text in labels and hover cards', async ($, on) => {
   const original = { ...STRINGS.ko }
   const noop = () => undefined
-  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
+  const actions = { toggleAuto: noop, toggleWarm: noop, compact: noop, clear: noop, handoff: noop, toggleLog: noop, toggleAgents: noop, openSettings: noop, toggleEffortMenu: noop, pickEffort: noop }
   try {
     STRINGS.ko['band.auto'] = '자동'
     STRINGS.ko['band.high'] = '높음'
@@ -280,7 +282,7 @@ const ALERTS: AlertView[] = [
 
 test('every alert draws on both surfaces', async ($, on) => {
   const noop = () => undefined
-  const actions = { compact: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
+  const actions = { compact: noop, clear: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
   ALERTS.forEach((alert, i) => drawPane(on, 'alert-' + i, (el, surface) => renderAlert(el, frameOf(surface), alert, actions)))
   for (const surface of SURFACES) {
     for (let i = 0; i < ALERTS.length; i++) {
@@ -294,7 +296,7 @@ test('every alert draws on both surfaces', async ($, on) => {
 test('alert choices reach their callbacks', async ($, on) => {
   const { calls, fn } = recorder()
   const actions = {
-    compact: fn('compact'), handoff: fn('handoff'), dismiss: fn('dismiss'), toggleSave: fn('save'), openSettings: fn('settings'), noteInput: fn('note'),
+    compact: fn("compact"), clear: fn("clear"), handoff: fn("handoff"), dismiss: fn("dismiss"), toggleSave: fn('save'), openSettings: fn('settings'), noteInput: fn('note'),
     setHandoffKind: fn('kind'), setHandoffAfter: fn('after'), go: fn('go'), copy: fn('copy'), openNew: fn('open-new'),
   }
   drawPane(on, 'cold', (el, surface) => renderAlert(el, frameOf(surface), ALERTS[0]!, actions))
@@ -333,7 +335,7 @@ function mascots(tree: unknown): Drawn[] {
 
 test('each alert shows 리플이 with the face of its state, its gauge in 5% steps; the terminal keeps a text mark', async ($, on) => {
   const noop = () => undefined
-  const actions = { compact: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
+  const actions = { compact: noop, clear: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
   const variants: [string, AlertView][] = [
     ['swamp-59', { kind: 'swamp', percent: 59, tokens: 118_000 }],
     ['swamp-61', { kind: 'swamp', percent: 61, tokens: 122_000 }],
@@ -624,7 +626,7 @@ test('every picture is a plain image, 리플이 the one face, and every blank pr
   // over it (kit.tsx), never from a blank button over nothing.
   const noop = () => undefined
   const setupActions = { patch: noop, jevKey: noop, testJev: noop, openAllSettings: noop, back: noop, next: noop, finish: noop, skip: noop }
-  const alertActions = { compact: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
+  const alertActions = { compact: noop, clear: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
   const cases: [string, Draw][] = [
     ['one-quick', (el, surface) => renderSettings(el, frameOf(surface, 64, 30), { settings: { ...SETTINGS, jevSource: 'typesafe' }, jev: { source: null, test: { state: 'idle' } } }, QUICK_ACTIONS)],
     ...([1, 2, 3, 4] as const).map((step): [string, Draw] => ['one-setup-' + step, (el, surface) => renderSetup(el, frameOf(surface, 64, 30), { step, draft: SETTINGS, jev: { source: null, test: { state: 'idle' } } }, setupActions)]),
@@ -644,7 +646,7 @@ test('every picture is a plain image, 리플이 the one face, and every blank pr
 
 test('a card says one thing: at most one main action, the others quiet, one way to let it go', async ($, on) => {
   const noop = () => undefined
-  const alertActions = { compact: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
+  const alertActions = { compact: noop, clear: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop }
   const all: AlertView[] = [...ALERTS, { kind: 'hot', limitKind: 'five_hour', percent: 97, save: true }]
   all.forEach((alert, i) => drawPane(on, 'say-' + i, (el, surface) => renderAlert(el, frameOf(surface), alert, alertActions)))
   for (let i = 0; i < all.length; i++) {
@@ -681,7 +683,7 @@ test('no drawing cuts its text: no truncating Text on any surface', async ($, on
     ['cut-agents', (el, surface) => renderAgents(el, frameOf(surface, 40), { agents: AGENTS.map(a => ({ ...a, description: a.description + ' and a much longer tail of words that runs past any pane width', state: 'running' as const })), now: NOW, showDone: true }, { toggleDone: noop })],
     ['cut-agents-done', (el, surface) => renderAgents(el, frameOf(surface, 40), { agents: AGENTS, now: NOW, showDone: true }, { toggleDone: noop })],
     ['cut-log', (el, surface) => renderLog(el, frameOf(surface, 40), { rows: [{ at: '2026-10-10T13:19:10', source: 'a-very-long-requested-model-name@high', target: 'another-very-long-routed-model-name', provider: 'opencode-go', status: 200, ok: true, ms: 2140 }], mineOnly: false }, { toggleScope: noop })],
-    ...ALERTS.map((alert, i): [string, Draw] => ['cut-alert-' + i, (el, surface) => renderAlert(el, frameOf(surface, 40), alert, { compact: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop })]),
+    ...ALERTS.map((alert, i): [string, Draw] => ['cut-alert-' + i, (el, surface) => renderAlert(el, frameOf(surface, 40), alert, { compact: noop, clear: noop, handoff: noop, dismiss: noop, toggleSave: noop, openSettings: noop, noteInput: noop, setHandoffKind: noop, setHandoffAfter: noop, go: noop, copy: noop, openNew: noop })]),
   ]
   for (const [id, draw] of cases) drawPane(on, id, draw)
   for (const surface of SURFACES) {
@@ -697,7 +699,7 @@ test('no drawing cuts its text: no truncating Text on any surface', async ($, on
 
 // ---- The band holds still (2026-10-10) ----------------------------------------------------------
 
-const BAND_ACTIONS = { toggleAuto: () => undefined, toggleWarm: () => undefined, compact: () => undefined, handoff: () => undefined, toggleLog: () => undefined, toggleAgents: () => undefined, openSettings: () => undefined, toggleEffortMenu: () => undefined, pickEffort: () => undefined }
+const BAND_ACTIONS = { toggleAuto: () => undefined, toggleWarm: () => undefined, compact: () => undefined, clear: () => undefined, handoff: () => undefined, toggleLog: () => undefined, toggleAgents: () => undefined, openSettings: () => undefined, toggleEffortMenu: () => undefined, pickEffort: () => undefined }
 const unhandled = (tree: unknown) => JSON.stringify(tree).replace(/"handle":\d+/g, '')
 
 test('within a minute the band draws the same tree; a minute on, only the countdown changes', async ($, on) => {
@@ -838,14 +840,16 @@ test('the band names the mode that is on, cut to a slot of its own that keeps it
   }
 })
 
-test('Handoff advised, the desktop band keeps the route and every control in one row at 700 px (Korean, Chinese), 770 px (English, Japanese), 870 px (Spanish, Portuguese)', async ($, on) => {
+test('Handoff advised, the desktop band keeps the route and every control in one row at 770 px (Chinese), 830 px (Korean, English, Japanese), 870 px (Spanish, Portuguese)', async ($, on) => {
   // The band counts every slot at a fixed width (never by value), drops the controls' words, then
   // the quietest facts, until the route and the controls fit; the reason takes what is left.
+  // The Clear and Compact icons joined the row (2026-10-14), so the narrowest window grew by
+  // about a control: Hangul labels are the widest, so Korean moved to 830.
   const busy: DashboardView = { ...DASH, effort: { level: 'xhigh', mode: 'manual' }, handoff: 'advised', agents: { live: 2, total: 3 }, warm: { on: true, pings: 3, cost: 0 } }
   const langs = Object.keys(STRINGS) as (keyof typeof STRINGS)[]
   // Cells counted at 8.8 px (the 14 px measure the band used before, 2026-10-10): a margin over
   // the host's 7.917 px for the site's padding and the band's own border.
-  const columns = (lang: string) => Math.floor((lang === 'es' || lang === 'pt' ? 870 : lang === 'en' || lang === 'ja' ? 770 : 700) / 8.8)
+  const columns = (lang: string) => Math.floor((lang === 'es' || lang === 'pt' ? 870 : lang === 'zh' ? 770 : lang === 'ko' || lang === 'en' || lang === 'ja' ? 830 : 770) / 8.8)
   for (const lang of langs) drawPane(on, 'row-' + lang, el => renderBand(el, { ...frameOf('desktop', columns(lang)), lang }, busy, { ...BAND_ACTIONS, hide: () => undefined }))
   for (const lang of langs) {
     const ui = await mount($, 'row-' + lang, 'desktop', columns(lang))
@@ -855,3 +859,89 @@ test('Handoff advised, the desktop band keeps the route and every control in one
     await ui.unmount()
   }
 })
+
+// 2026-10-14: Auto's word is the control itself (the switch picture is gone): pressing the word
+// toggles, and the state is in its own drawing — lit violet while on, a quiet ghost while off.
+test('the Auto word toggles on press and draws its state', async ($, on) => {
+  const { calls, fn } = recorder()
+  const actions = { ...BAND_ACTIONS, toggleAuto: fn('auto') }
+  drawPane(on, 'word-auto', el => renderBand(el, frameOf('desktop'), DASH, actions))
+  drawPane(on, 'word-auto-off', el => renderBand(el, frameOf('desktop'), { ...DASH, auto: false }, actions))
+  const on_ = await mount($, 'word-auto', 'desktop')
+  // Lit while on: the picture's root class reads on; the old switch is gone.
+  expect(await on_.find({ type: 'Box', key: 'word-on-auto' })).toBeDefined()
+  expect(await on_.findAll({ type: 'Svg' }).then(list => list.some(svg => svg.props.alt === 'Auto' && String(svg.props.source).includes('class="on"')))).toBe(true)
+  // The press is on the word itself: it reaches the toggle.
+  await on_.press({ key: 'auto' })
+  expect(calls).toEqual(['auto'])
+  await on_.unmount()
+  // Off, the same slot draws the quiet ghost instead of the lit pill.
+  const off = await mount($, 'word-auto-off', 'desktop')
+  expect(await off.find({ type: 'Box', key: 'ghost-auto' })).toBeDefined()
+  expect(await off.findAll({ type: 'Svg' }).then(list => list.some(svg => svg.props.alt === 'Auto' && String(svg.props.source).includes('class="off"')))).toBe(true)
+  await off.unmount()
+})
+
+// 2026-10-14: at the band's narrowest real width (94 columns) everything asked of the band holds:
+// the limit and the new icons stay; Handoff, Auto and the way out draw with them.
+test('at 94 columns with Handoff advised the limit is drawn beside the new controls', async ($, on) => {
+  const busy: DashboardView = { ...DASH, limit: { kind: 'seven_day', percent: 42, resetsAt: '2026-10-10T15:40:00', save: false }, handoff: 'advised', extras: ['context', 'limits'] }
+  drawPane(on, 'n94', el => renderBand(el, frameOf('desktop', 94), busy, { ...BAND_ACTIONS, hide: () => undefined }))
+  const ui = await mount($, 'n94', 'desktop', 94)
+  expect(await ui.find({ type: 'Box', key: 'fact-limit' }), 'limit at 94').toBeDefined()
+  expect(await ui.find({ type: 'Box', key: 'fact-cache' }), 'cache at 94').toBeDefined()
+  expect(await ui.find({ type: 'Box', key: 'fact-effort' })).toBeDefined()
+  expect(await ui.find({ type: 'Button', key: 'route' })).toBeDefined()
+  for (const key of ['handoff', 'auto', 'warm', 'agents', 'compact', 'clear', 'settings', 'hide']) expect(await ui.find({ type: 'Button', key }), key + ' at 94').toBeDefined()
+  await ui.unmount()
+})
+
+/** Every tip as drawn: the words it shows, and the hover that reveals it. */
+function tipsOf(tree: unknown): { text: string; display: unknown; scope: string | undefined }[] {
+  const out: { text: string; display: unknown; scope: string | undefined }[] = []
+  walk(tree, n => {
+    const hover = (n as Drawn & { hover?: { scope?: string; display?: string } }).hover
+    if (n.type !== 'Box' || n.props?.display !== 'none' || hover?.display !== 'flex' || !hover.scope) return
+    const shown = [...walkText(n)]
+    out.push({ text: shown.join(''), display: n.props?.display, scope: hover?.scope })
+  })
+  return out
+}
+function* walkText(node: unknown): Generator<string> {
+  if (typeof node === 'string') { yield node; return }
+  if (!node || typeof node !== 'object') return
+  if (Array.isArray(node)) { for (const c of node) yield* walkText(c); return }
+  const n = node as Drawn
+  if (n.type === 'Text') yield (n.children ?? []).join('')
+  for (const c of n.children ?? []) yield* walkText(c)
+}
+
+// 2026-10-14: at the band's real width (100 columns) every slot is drawn and the row leaves nothing
+// free, so a tip must not depend on that free room; each rests hidden (and carries no `key`: a keyed
+// Box drawn display "none" is refused as a hover scope) and reveals through the scope its fact or
+// control joins, so a control's tip shows in a full band.
+test('a control\'s tip is drawn in a full band, hidden and revealed by its scope', async ($, on) => {
+  const busy: DashboardView = { ...DASH, limit: { kind: 'seven_day', percent: 42, resetsAt: '2026-10-10T15:40:00', save: false }, handoff: 'advised', extras: ['context', 'limits'] }
+  drawPane(on, 'n100', el => renderBand(el, frameOf('desktop', 100), busy, { ...BAND_ACTIONS, hide: () => undefined }))
+  const ui = await mount($, 'n100', 'desktop', 100)
+  const tree = await ui.drawn()
+  const tips = tipsOf(tree)
+  // One tip per fact and control (the effort, the context, the cache, the limit, the route, and
+  // every control but Handoff, which names itself in its pill) plus the way out — the row is full
+  // and all are drawn.
+  expect(tips.length, 'tips: ' + tips.map(t => t.text.slice(0, 14)).join(' / ')).toBe(12)
+  const words = (start: string) => tips.find(tip => tip.text.startsWith(start))
+  for (const start of ['Opus 5.5 · Auto', 'Context 38%', 'Prompt cache', 'Weekly limit 42%', 'Last route', 'Effort Auto', 'Keep cache warm', 'Agents:', 'Compact — ', 'New start (/clear) — ', 'Ripple settings', 'Hide the band']) {
+    expect(words(start), start).toBeDefined()
+  }
+  for (const tip of tips) {
+    expect(tip.display, tip.text).toBe('none')
+    expect(typeof tip.scope, tip.text).toBe('string')
+  }
+  // Hovering the compact control (its own hover carries the same scope) reveals the compact tip.
+  const compact = words('Compact — ')!
+  const joined = JSON.stringify(tree).includes('"scope":"' + compact.scope + '"')
+  expect(joined, 'the compact control joins its tip\'s scope').toBe(true)
+  expect(await ui.find({ type: 'Button', key: 'compact' })).toBeDefined()
+  await ui.unmount()
+})

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

@@ -319,7 +319,7 @@ declare module 'claude-code' {
       judgeDown: string | null
       advice: string | null
       handoff: { stage: HandoffStage; kind: HandoffKind; text?: string } | null
-      panel: 'settings' | 'setup' | 'compact' | 'handoff' | null
+      panel: 'settings' | 'setup' | 'compact' | 'clear' | 'handoff' | null
       busy: boolean
       decidingSince: number | null
       heldPick: Pick | null

package/dist/router/src/admin.js

@@ -1028,11 +1028,13 @@ async function probeProvider(body, probeFetch = fetchWithTimeout) {
     const responses = openai && body.wire === "responses" && !body.preset;
     const checkUrl = responses ? responsesUrl(body.url) : openai ? chatCompletionsUrl(body.url) : messagesUrl(body.url);
     const checkModel = presetProbeModel(body.preset) ?? models[0]?.id ?? body.probeModel ?? "test";
+    // 16 tokens, as on Responses: some vendors refuse a smaller cap outright (B.ai: "max_tokens must be
+    // greater than 2", #57), which read as a failed connection though the key and URL were right.
     const checkBody = responses
         ? { model: checkModel, max_output_tokens: 16, stream: false, store: false, input: "hi" }
         : openai
-            ? { model: checkModel, max_tokens: 1, stream: false, messages: [{ role: "user", content: "hi" }] }
-            : { model: checkModel, max_tokens: 1, messages: [{ role: "user", content: "hi" }] };
+            ? { model: checkModel, max_tokens: 16, stream: false, messages: [{ role: "user", content: "hi" }] }
+            : { model: checkModel, max_tokens: 16, messages: [{ role: "user", content: "hi" }] };
     const label = responses ? "responses endpoint" : openai ? "chat completions endpoint" : "messages endpoint";
     try {
         const response = await probeFetch(checkUrl, {
@@ -1179,8 +1181,9 @@ function effortUndeclared(p) {
  *
  * Read again here rather than reusing what the job started with: the user may have saved from the
  * GUI while the measurements ran, and writing back a stale copy would silently revert that save.
- * Only a model that is still present is touched, and only into a blank field — a `wire` or
- * `effortLevels` already on the model is the user's, and an explicitly empty array is a decision
+ * Only a model that is still present is touched, and only into a blank field — a `wire`,
+ * `effortLevels` or `contextWindow` already on the model is the user's or the vendor's, and an
+ * explicitly empty ladder is a decision
  * (it disables the provider fallback), not an empty slot. A model whose measurement errored is
  * left entirely alone. The result is validated with the same `validate` the GUI's save uses, so a
  * bad edit is refused rather than written.
@@ -1203,12 +1206,14 @@ function applyMeasurements(configFile, results) {
             const model = provider.models.find((entry) => entry.id === result.id);
             if (!model)
                 continue;
-            const before = `${model.wire ?? ""}|${model.effortLevels ? model.effortLevels.join(",") : "∅"}`;
+            const before = `${model.wire ?? ""}|${model.effortLevels ? model.effortLevels.join(",") : "∅"}|${model.contextWindow ?? "∅"}`;
             if (model.wire === undefined)
                 model.wire = result.wire;
             if (model.effortLevels === undefined && result.effortLevels !== undefined)
                 model.effortLevels = result.effortLevels;
-            if (`${model.wire ?? ""}|${model.effortLevels ? model.effortLevels.join(",") : "∅"}` !== before)
+            if (model.contextWindow === undefined && result.contextWindow !== undefined)
+                model.contextWindow = result.contextWindow;
+            if (`${model.wire ?? ""}|${model.effortLevels ? model.effortLevels.join(",") : "∅"}|${model.contextWindow ?? "∅"}` !== before)
                 applied++;
         }
     }
@@ -1249,6 +1254,56 @@ export function measureUnsettledModels(deps) {
     }
     return started;
 }
+/**
+ * Give models already saved without a context window the one the catalogue states.
+ *
+ * OpenCode's `/models` reports ids alone, so a provider set up before the catalogue's `limit.context`
+ * was read keeps no window and falls back to `cli.autoCompactWindow` — a quarter of a 1M model's real
+ * window. The measurement folds the catalogue's window in, but only over the models it runs on and
+ * only through its own write; this pass reaches the models already on disk, once, at start-up. Only
+ * into a blank field, through the same validated write, so a window the user or the vendor set is
+ * never overwritten. Returns the `provider/model` ids it filled.
+ */
+export async function backfillContextWindows(deps) {
+    const catalog = deps.modelCatalog ? await deps.modelCatalog().catch(() => undefined) : undefined;
+    if (!catalog) {
+        deps.log.warn("admin: context windows not backfilled: the catalogue could not be had");
+        return [];
+    }
+    let current;
+    try {
+        current = JSON.parse(fs.readFileSync(deps.configFile, "utf8"));
+    }
+    catch (e) {
+        deps.log.warn(`admin: context windows not backfilled: could not read config: ${errorText(e)}`);
+        return [];
+    }
+    const filled = [];
+    for (const [name, provider] of Object.entries(current.providers)) {
+        if (!("models" in provider) || !provider.models)
+            continue;
+        const preset = "preset" in provider ? provider.preset : undefined;
+        for (const model of provider.models) {
+            if (model.contextWindow !== undefined)
+                continue;
+            const entry = catalogEntry(catalog, preset, model.id);
+            if (entry?.contextWindow === undefined)
+                continue;
+            model.contextWindow = entry.contextWindow;
+            filled.push(`${name}/${model.id}`);
+            deps.log.info(`admin: ${name}/${model.id} context window ${entry.contextWindow} (catalogue)`);
+        }
+    }
+    if (filled.length === 0)
+        return [];
+    const errors = validate(current);
+    if (errors.length > 0) {
+        deps.log.warn(`admin: context windows not backfilled: config did not validate: ${errors[0]}`);
+        return [];
+    }
+    writeConfigFile(deps.configFile, current);
+    return filled;
+}
 /**
  * Declare each Claude release the account has gained on every native Anthropic provider that
  * declares an older model of the same family (`newClaudeReleases`). The declared list was whatever
@@ -1328,6 +1383,10 @@ async function runMeasureJob(jobId, providerName, models, deps) {
         const measured = await measureModel(id, candidates, known ? [] : ladder, { fetch: fetchImpl, ...(sessionHeader ? { sessionHeader } : {}), ...(headers ? { headers } : {}) }, { discover: discover && !known });
         if (stated && measured.wire)
             measured.effortLevels = stated;
+        // The wire was answered, so the model exists: the catalogue's own window travels with the result
+        // and is written only into a model that has none (see applyMeasurements).
+        if (measured.wire && listed?.contextWindow !== undefined)
+            measured.contextWindow = listed.contextWindow;
         job.results.push(measured);
         job.done++;
         deps.log.info(`admin: measured ${providerName}/${id} -> ${measured.error ? `error ${measured.error}` : `wire ${measured.wire}${measured.effortLevels ? ` effort ${measured.effortLevels.join(",")}${known ? " (catalogue)" : ""}` : ""}`}`);

package/dist/router/src/agents.js

@@ -36,6 +36,11 @@ const BODY = [
     "다른 에이전트에게 넘기지 않는다. 프롬프트 첫 줄의 `[[ripple: …]]` 표식은 라우팅용이니 무시한다.",
     "**시키지 않은 파일은 만들지 않는다.** 작업 지시에 결과물 경로가 없으면 조사·감사라도 작업 디렉터리(cwd)에 아무 파일도 남기지 않는다.",
     "작업 지시가 결과물 경로(파일·폴더)를 정했으면 조사·감사·대조 작업이라도 그 경로에는 반드시 만든다. 그 밖의 메모·사본·임시 파일은 `/tmp` 아래에만 만들고, 끝나면 지운다.",
+    // Claude Code tells a bypass/auto session to read and edit through Bash (since CLI 2.1.234). After it
+    // arrived Bash edits went from 32% to 78% and Read calls from 2,897 to 151 in the operator's
+    // sessions, and details went missing (brain, 2026-08-25); workers here read with `sed -n`/`cat` more
+    // than with Read (2026-10-14). The operator's own rule, given to the workers too:
+    "**소스 파일 읽기와 수정은 전용 도구로 한다.** 처음 만지는 파일은 Read로 통독하고(필요하면 다시 읽는다), 수정은 Edit, 새 파일은 Write로 한다. `cat`·`sed -n`·`head`로 조각만 읽어 넘기지 않고, `sed -i`·heredoc 덮어쓰기·스크립트 재작성으로 소스를 고치지 않는다 — 간격·정렬·주석이 조용히 깎인다. Bash는 검색(grep/rg)·실행·테스트·빌드, 그리고 수십 곳 이상의 기계적 일괄 치환(끝나면 `git diff`로 확인)에만 쓴다.",
 ].join("\n");
 /**
  * Added to the body when a ChatGPT provider is configured: how a worker makes an image. A worker has

package/dist/router/src/catalog.js

@@ -5,13 +5,15 @@
 // model, one after another. With upstream latency swinging from 0.5s to 25s on identical one-token
 // requests (glm-5.3-flash, measured 2026-10-02), three models took 2m33s.
 //
-// models.dev (https://models.dev/api.json, maintained by the team behind OpenCode) states both for
-// every model OpenCode serves: `reasoning_options` lists the effort values, and `provider.npm` names
-// the SDK the OpenCode client speaks to it with. It is also more accurate than asking: a 200 only
-// says a level was not refused, and glm-5.3-flash answered 200 to seven levels where the catalogue
-// lists `low`/`high`/`max` — the rest were accepted and, as far as anything can tell, ignored. And
-// muse-spark-1.3-contributor names `max` in its own error message, refuses it when sent, and the
-// catalogue never lists it.
+// models.dev (https://models.dev/api.json, maintained by the team behind OpenCode) states three
+// things for every model OpenCode serves: `reasoning_options` lists the effort values, `provider.npm`
+// names the SDK the OpenCode client speaks to it with, and `limit.context` is the model's context
+// window — which OpenCode's own `/models` does not report at all. It is also more accurate than
+// asking on effort: a 200 only says a level was not refused, and glm-5.3-flash answered 200 to seven
+// levels where the catalogue lists `low`/`high`/`max` — the rest were accepted and, as far as
+// anything can tell, ignored. And muse-spark-1.3-contributor's catalogue entry omits `max` even
+// though the live model takes it: measured 2026-10-14, `reasoning.effort: "max"` was answered 200
+// with effort echoed "max" and 253 reasoning tokens against 134 at xhigh.
 //
 // The catalogue is community-maintained and a new model can arrive a day late; a model it does not
 // list is measured exactly as before.
@@ -56,7 +58,15 @@ export function catalogEntry(catalog, preset, modelId) {
     else if (model.reasoning === false) {
         effortLevels = [];
     }
-    return { ...(wire ? { wire } : {}), ...(effortLevels ? { effortLevels } : {}) };
+    // The catalogue's own window, which OpenCode's `/models` does not carry. A fractional or
+    // non-positive `context` is not a window we would hand Claude Code, so it is left unstated.
+    const context = model.limit?.context;
+    const contextWindow = typeof context === "number" && Number.isInteger(context) && context > 0 ? context : undefined;
+    return {
+        ...(wire ? { wire } : {}),
+        ...(effortLevels ? { effortLevels } : {}),
+        ...(contextWindow !== undefined ? { contextWindow } : {}),
+    };
 }
 let cached;
 /**

package/dist/router/src/index.js

@@ -14,12 +14,13 @@ import { CertStore } from "./certs.js";
 import { Logger } from "./log.js";
 import { UpstreamHealth, EXIT_UPSTREAM_UNREACHABLE } from "./health.js";
 import { Proxy } from "./proxy.js";
-import { adoptNewClaudeModels, measureUnsettledModels, startAdmin } from "./admin.js";
+import { adoptNewClaudeModels, backfillContextWindows, measureUnsettledModels, startAdmin } from "./admin.js";
 import { loadModelCatalog } from "./catalog.js";
 import { RequestLog } from "./requestlog.js";
 import { OpenAiIngress } from "./ingress/server.js";
 import { ObservedClaudeCodeAuth } from "./providers/anthropic-observed.js";
 import { VERSION } from "./version.js";
+import { allowLongSilences } from "./providers/retry.js";
 // Startup timing. Claude Desktop routes *all* its traffic through us in picker mode, so every
 // second before the socket is open is a second the app cannot reach anything (ERR_PROXY_-
 // CONNECTION_FAILED, observed 2026-09-14 after a reboot: 26s between exec and listening).
@@ -85,6 +86,8 @@ const health = new UpstreamHealth(() => store.get().health.maxConsecutiveUpstrea
     setTimeout(() => process.exit(EXIT_UPSTREAM_UNREACHABLE), 100);
 });
 const observedClaudeCodeAuth = new ObservedClaudeCodeAuth(path.join(home, "claude-auth-observed.json"));
+// Before any provider fetches: a reasoning model may stay silent past fetch's 300s default.
+allowLongSilences();
 const proxy = new Proxy({ config: () => store.get(), log, certs, health, home, requests, observedClaudeCodeAuth });
 const ingress = new OpenAiIngress({ config: () => store.get(), log, requests, home, observedClaudeCodeAuth, chatgpt: (name) => proxy.chatgptForCodex(name) });
 process.on("uncaughtException", (e) => log.error(`uncaught ${e.stack ?? e}`));
@@ -173,9 +176,15 @@ proxy
     const admin = await startAdmin(adminDeps);
     log.info(`clauderipple admin GUI on http://127.0.0.1:${admin.port}/`);
     setImmediate(premintLeaves);
-    // A minute in, once start-up traffic has settled: a few one-token requests per model whose
-    // effort nobody has measured yet, so effort works without the owner re-saving the provider.
-    setTimeout(() => measureUnsettledModels(adminDeps), 60_000).unref();
+    // A minute in, once start-up traffic has settled: first the catalogue's context windows are
+    // written into models already saved without one (a one-shot pass), then a few one-token requests
+    // per model whose effort nobody has measured yet, so effort works without the owner re-saving the
+    // provider. The backfill runs first so its write lands before the measured jobs re-read the config.
+    setTimeout(() => {
+        void backfillContextWindows(adminDeps)
+            .catch((e) => log.warn(`context windows: ${e.message}`))
+            .finally(() => measureUnsettledModels(adminDeps));
+    }, 60_000).unref();
     // Claude releases reach the declared models without a ClaudeRipple release: checked a minute in,
     // then every six hours (the catalogue itself is cached for an hour).
     const adopt = () => void adoptNewClaudeModels(adminDeps).catch((e) => log.warn(`claude models: ${e.message}`));

package/dist/router/src/providers/chatgpt/index.js

@@ -607,6 +607,14 @@ export class ChatGptAdapter {
             return null;
         }
         this.noteRateLimits(tokens, parsed);
+        // The backend's own answer that every window has room ends a usage-limit cooldown early: the
+        // limit was reset or the plan topped up, and the account stayed refused until the old reset time
+        // otherwise (2026-10-14: credits added at 15:50, still "cooling" until 21:42). Only this asked-for
+        // figure does it, never the headers of the 429 that started the cooldown.
+        if (exhaustedForMs(parsed) === undefined && this.accounts.peekCredentials().some((c) => c.id === tokens.id && !this.pool.hasUsable(this.name, [c]))) {
+            this.pool.clear(this.name, tokens.id);
+            this.log.info(`chatgpt ${this.name}: account ${tokens.ownerId.slice(0, 8)} has room again; back in rotation`);
+        }
         return parsed;
     }
     /** One in-flight catalogue lookup shared by every caller, and the last good list for an hour. */