clauderipple 0.9.2 → 0.9.4

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

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

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

package/dist/router/src/providers/retry.js

@@ -22,7 +22,22 @@
 // any status or byte is sent, so a retry cannot splice two answers together. Once the first byte is
 // out the turn is committed and this must not be used.
 import { setTimeout as sleep } from "node:timers/promises";
+import { Agent, setGlobalDispatcher } from "undici";
 import { classify } from "../pool.js";
+/**
+ * How long a translated provider's response may stay silent. Node's `fetch` gives up after 300s
+ * without a byte (`UND_ERR_BODY_TIMEOUT`, reproduced 2026-10-14: an SSE response that went quiet was
+ * cut at 300.98s). A reasoning model says nothing while it thinks: Muse Spark 1.3 at xhigh on a
+ * 100k+ context thought for minutes per step, and every one of its 529s that day ended at 303–305s,
+ * while every step that finished did so under 280s — the whole step thrown away and asked again.
+ * OpenCode's own CLI has no such limit. Fifteen minutes is past Claude Code's own request timeout,
+ * so the client, not this, decides when a turn has taken too long.
+ */
+export const UPSTREAM_SILENCE_MS = 15 * 60_000;
+/** Every `fetch` in this process waits `ms` for headers and between body bytes. Called at startup. */
+export function allowLongSilences(ms = UPSTREAM_SILENCE_MS) {
+    setGlobalDispatcher(new Agent({ bodyTimeout: ms, headersTimeout: ms }));
+}
 /** Attempts in total — one ask plus nine retries, matching the CLI's own ceiling (2026-09-21). */
 export const DEFAULT_ATTEMPTS = 10;
 const RETRY_BASE_MS = 250;

package/dist/router/src/version.js

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

package/dist/ui/app.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clauderipple",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Use GPT (any ChatGPT plan with Codex), DeepSeek and 400+ other models in the Claude Desktop Code tab and Claude Code while staying signed in to your Claude subscription — no third-party gateway mode. Several ChatGPT accounts that take over when one runs out, in Codex too.",
   "license": "GPL-3.0-only",
   "workspaces": [
@@ -77,6 +77,7 @@
     "url": "https://github.com/PBJ-2/clauderipple/issues"
   },
   "dependencies": {
-    "proper-lockfile": "^4.1.2"
+    "proper-lockfile": "^4.1.2",
+    "undici": "7.24.4"
   }
 }