clauderipple 0.9.3 → 0.9.5

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/presets.js

@@ -199,6 +199,9 @@ export const PRESETS = [
         authHeader: "authorization-bearer",
         wire: "responses",
         sessionHeader: "x-opencode-session",
+        // Measured 2026-10-14 on muse-spark-1.3-contributor: `include` and `summary` are accepted, the
+        // sealed item comes back on a tool-bearing turn, and replaying it in place answers 200.
+        sealedReasoning: true,
         modelsUrl: "https://opencode.ai/zen/go/v1/models",
         modelsAuthHeader: "authorization-bearer",
         // Every wire below is from the endpoint table OpenCode publishes per model

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

@@ -8,6 +8,7 @@ import { SseParser } from "./sse.js";
 import { fetchWithRetry } from "../retry.js";
 import { looksLikeAuth } from "../openai/index.js";
 import { StreamMapper, conversationKey, estimateTokens, formatSse, serverToolNames, toResponsesRequest, toolNameRestoreMap } from "./translate.js";
+import { refusesReplayedReasoning } from "../../reasoning.js";
 import { providerExhaustion } from "../../health.js";
 import { credentialHeaderValues, redactErrorText } from "../../redact.js";
 import { codexClientVersion, latestCodexVersion, parseCodexCatalog } from "./catalog.js";
@@ -607,6 +608,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. */
@@ -955,6 +964,27 @@ export class ChatGptAdapter {
             res.end();
         return { status: upstream.status, bytes, ...(usage ? { usage } : {}), note: `codex passthrough account=${owner ? owner.slice(0, 8) : "caller"}` };
     }
+    /**
+     * The options one turn is translated with. The conversation is the storage (reasoning.ts), so what
+     * to replay is read out of the request itself; `carried` is filled in as the input is built and the
+     * outcome lands in the request log. `replay: false` is the retry after the backend refused that
+     * carrier, and it puts back exactly the request this adapter sent before any of this existed.
+     */
+    responsesOptions(carried, model, effort, replay = true) {
+        return {
+            model,
+            effort: effort ?? this.cfg.defaultEffort ?? "high",
+            identity: this.cfg.identity ?? true,
+            ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
+            replay,
+            // The envelope names this provider and this model, and the request builder refuses anything
+            // else: reasoning outlives the turn that made it, and a conversation moved to another model
+            // must not carry the old one's sealed state with it (reasoning.ts).
+            env: { p: this.name, m: model },
+            carried,
+            log: (line) => this.log.info(`chatgpt ${this.name}: ${line} (${model})`),
+        };
+    }
     /** Handle a fully-read Messages request. `model`/`effort` already resolved by routing. */
     async handle(req, res, path, json, model, effort) {
         if (path.startsWith("/v1/messages/count_tokens")) {
@@ -967,13 +997,9 @@ export class ChatGptAdapter {
         const serverTools = serverToolNames(json.tools);
         if (serverTools.size > 0)
             this.log.warn(`chatgpt ${this.name}: dropped server tools for ${model}: ${[...serverTools].join(", ")} (Anthropic runs these; this provider cannot)`);
-        const upstreamReq = toResponsesRequest(json, {
-            model,
-            effort: effort ?? this.cfg.defaultEffort ?? "high",
-            identity: this.cfg.identity ?? true,
-            ...(this.cfg.instructionsAppend ? { instructionsAppend: this.cfg.instructionsAppend } : {}),
-        });
-        const body = JSON.stringify(upstreamReq);
+        const carried = { replayed: 0, undecodable: 0 };
+        let upstreamReq = toResponsesRequest(json, this.responsesOptions(carried, model, effort));
+        let body = JSON.stringify(upstreamReq);
         const cacheKey = upstreamReq.prompt_cache_key;
         // Input estimate for message_start: a conversation only grows, so the last measured total is a floor.
         const startInput = Math.max(estimateTokens(json), this.lastInputByKey.get(cacheKey) ?? 0);
@@ -983,7 +1009,7 @@ export class ChatGptAdapter {
         // One account answers the turn. Which one is decided here, and a refusal before any byte has
         // reached the client moves the same turn to the next account, so the client is answered on its
         // first ask. The conversation stays on the account that answered: moving it costs the cache.
-        const sent = await this.sendToAnAccount({
+        const ask = () => this.sendToAnAccount({
             conversation: cacheKey,
             path: "/codex/responses",
             body,
@@ -1006,6 +1032,18 @@ export class ChatGptAdapter {
                 };
             },
         });
+        let sent = await ask();
+        // A 4xx that names reasoning is the backend refusing the sealed reasoning we replayed — the blob
+        // was minted by the model that is no longer answering, or by another account. The summary is
+        // worth nothing without it, so the turn is asked once without: replaying is an optimisation and
+        // must never be the reason a user's turn fails (reasoning.ts).
+        if (carried.replayed > 0 && sent.kind === "refused" && refusesReplayedReasoning(sent.status, sent.text)) {
+            this.log.warn(`chatgpt ${this.name}: upstream ${sent.status} refused ${carried.replayed} replayed reasoning item(s) for ${model}; asking again without them: ${sent.text.slice(0, 200)}`);
+            upstreamReq = toResponsesRequest(json, this.responsesOptions({ replayed: 0, undecodable: 0 }, model, effort, false));
+            body = JSON.stringify(upstreamReq);
+            carried.replayed = 0;
+            sent = await ask();
+        }
         if (sent.kind !== "ok") {
             res.off("close", onClose);
             if (sent.kind === "aborted")
@@ -1053,7 +1091,7 @@ export class ChatGptAdapter {
         if (this.cfg.debugDump === "all")
             this.dump(upstream.status, json, upstreamReq, "");
         const wantStream = json.stream === true;
-        const mapper = new StreamMapper(model, startInput, toolNameRestoreMap(json));
+        const mapper = new StreamMapper(model, startInput, toolNameRestoreMap(json), this.name);
         const parser = new SseParser();
         let bytes = 0;
         let ping = null;
@@ -1171,8 +1209,8 @@ export class ChatGptAdapter {
             exhaustion,
             bytes,
             note: failure
-                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens})`
-                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason}${upstreamReq.service_tier ? " fast" : ""}`,
+                ? `${wantStream ? "mid-stream " : ""}${failure.type}: ${failure.message} (in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} replayed=${carried.replayed} reasoning=${mapper.reasoningCount})`
+                : `in=${u.input_tokens} cached=${u.cache_read_input_tokens} out=${u.output_tokens} stop=${mapper.stopReason} replayed=${carried.replayed} reasoning=${mapper.reasoningCount}${upstreamReq.service_tier ? " fast" : ""}`,
             usage: {
                 input: u.input_tokens,
                 cached: u.cache_read_input_tokens,