clauderipple 0.10.0 → 0.11.1

package/dist/mod/hooks/register.tsx

@@ -88,7 +88,6 @@ const effortMenuOpen = atom({ plugin: 'ripple', key: 'effortMenuOpen' } as const
 const agentsOpen = atom({ plugin: 'ripple', key: 'agentsOpen' } as const, false)
 const agentsShowDone = atom({ plugin: 'ripple', key: 'agentsShowDone' } as const, false)
 const agentOpen = atom({ plugin: 'ripple', key: 'agentOpen' } as const, null)
-const agentEarlier = atom({ plugin: 'ripple', key: 'agentEarlier' } as const, 0)
 const agentRunsOpen = atom({ plugin: 'ripple', key: 'agentRunsOpen' } as const, [])
 const agentsTick = atom({ plugin: 'ripple', key: 'agentsTick' } as const, 0)
 const jev = atom({ plugin: 'ripple', key: 'jev' } as const, { source: null, test: { state: 'idle' } })
@@ -1232,7 +1231,8 @@ async function frameOf($: EngineInterface, e: RenderInput): Promise<Frame> {
   const s = await currentSettings($)
   const columns = 'bodyColumns' in e.props ? e.props.bodyColumns : e.viewport?.columns ?? 100
   const maxRows = 'maxRows' in e.props ? e.props.maxRows : 'scroll' in e.props ? e.props.scroll.bodyRows : 1
-  return { surface: e.surface, columns, maxRows, now: await $.clock.now(), appearance: s.appearance, skin: s.skin, lang: await read($, lang) }
+  const offset = 'scroll' in e.props && !('maxRows' in e.props) ? e.props.scroll.offset : undefined
+  return { surface: e.surface, columns, maxRows, ...(offset ? { offset } : {}), now: await $.clock.now(), appearance: s.appearance, skin: s.skin, lang: await read($, lang) }
 }
 async function alertView($: EngineInterface, now: number): Promise<AlertView | null> {
   const language = await read($, lang)
@@ -1317,10 +1317,9 @@ function alertActions($: EngineInterface, view: AlertView): AlertActions {
 function agentsActions($: EngineInterface): AgentsActions {
   return {
     toggleDone: () => update($, agentsShowDone, value => !value),
-    open: async id => { await update($, agentEarlier, () => 0); await update($, agentRunsOpen, () => []); await update($, agentOpen, () => id) },
+    open: async id => { await update($, agentRunsOpen, () => []); await update($, agentOpen, () => id) },
     // Back on the list, the runs unfolded in that conversation fold again: it opens folded next time.
     back: async () => { await update($, agentRunsOpen, () => []); await update($, agentOpen, () => null) },
-    earlier: () => update($, agentEarlier, n => n + 1),
     toggleRun: id => update($, agentRunsOpen, ids => ids.includes(id) ? ids.filter(i => i !== id) : [...ids, id]),
   }
 }
@@ -1759,7 +1758,7 @@ export const register: Register = on => {
       // Read to be drawn again each second an agent runs (agentsClock): its elapsed time ticks.
       await read($, agentsTick)
       const id = await read($, agentOpen)
-      const open = id === null ? undefined : { id, talk: await agentTalk($, id), earlier: await read($, agentEarlier), runsOpen: await read($, agentRunsOpen) }
+      const open = id === null ? undefined : { id, talk: await agentTalk($, id), runsOpen: await read($, agentRunsOpen) }
       return renderAgents($.ui.resolve(e), frame, { agents: await read($, agents), now: frame.now, showDone: await read($, agentsShowDone), ...(open ? { open } : {}) }, agentsActions($)) as RenderElement
     } catch (error) { await report($, 'agents render', error); return next(e) }
   })

package/dist/mod/hooks/session.ts

@@ -68,8 +68,12 @@ function limitItemFromWindow(w: unknown, provider: string, type: string | undefi
   if (typeof used !== 'number' || !Number.isFinite(used)) return null
   const minutes = typeof o.window_minutes === 'number' && o.window_minutes > 0 ? o.window_minutes : undefined
   const reset = typeof o.reset_at === 'number' && Number.isFinite(o.reset_at) ? o.reset_at * (o.reset_at < 1e12 ? 1000 : 1) : NaN
-  // A window whose reset has passed no longer stands (as the ChatGPT reader has always said).
-  if (Number.isFinite(reset) && reset <= now) return null
+  // A window whose reset has passed starts again from nothing: it reads 0% until the provider next
+  // reports, not gone. Dropped, Claude's five-hour window vanished from the row the minute it reset,
+  // and the row read as one of Claude's figures cut off (2026-10-20).
+  if (Number.isFinite(reset) && reset <= now) {
+    return { provider, ...(type ? { type } : {}), ...(title ? { title } : {}), account, kind: kind as LimitKind, label: typeof o.label === 'string' ? o.label : '', ...(minutes !== undefined ? { windowMinutes: minutes } : {}), percent: 0 }
+  }
   return {
     provider,
     ...(type ? { type } : {}),

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

@@ -43,9 +43,13 @@ const BY: Record<NonNullable<AgentRec['pick']>['by'] | 'tier', string> = { haiku
 
 /** Finished agents the list shows before "more". */
 export const DONE_SHOWN = 4
-/** Conversation entries a page shows; "earlier" adds a page. */
-export const TALK_PAGE = 30
-/** Characters of a text entry drawn: a tree draws 100,000 characters in all (the engine's cut). */
+/**
+ * Characters of the conversation drawn in all, about: a tree draws 100,000 characters (the engine's
+ * cut), and the card and the page's chrome take some. Only a conversation past it loses its oldest
+ * entries; any other shows whole, as the Claude app's chat does.
+ */
+export const TALK_CHARS = 80_000
+/** Characters of a text entry drawn. */
 const TEXT_MAX = 3000
 const PROMPT_MAX = 2400
 const ANSWER_MAX = 12000
@@ -162,21 +166,30 @@ function cut(text: string, max: number): string {
   return text.length > max ? text.slice(0, max).trimEnd() + ' …' : text
 }
 
-type Page = { first?: AgentEntry; hidden: number; shown: AgentEntry[]; answer?: string }
+type Page = { first?: AgentEntry; dropped: number; shown: AgentEntry[]; answer?: string }
+
+/** Characters an entry draws, about: its text as cut, or a tool call's line. */
+function weight(entry: AgentEntry): number {
+  if (entry.kind === 'tool') return (entry.detail?.length ?? 0) + 40
+  return Math.min(entry.text.length, entry.kind === 'prompt' ? PROMPT_MAX : TEXT_MAX) + 40
+}
 
 /**
- * What a page of the conversation shows: the first prompt always (what it was asked), the latest
- * entries, how many earlier ones wait behind "earlier", and a finished agent's last words as its
- * answer.
+ * What the page shows: the first prompt always (what it was asked), every entry after it, and a
+ * finished agent's last words as its answer. Every entry, with no "earlier" to press: the owner
+ * read the agent's words behind it as hidden (2026-10-20). Only past TALK_CHARS do the oldest go,
+ * counted in `dropped`.
  */
-function pageOf(entries: readonly AgentEntry[], earlier: number, finished: boolean): Page {
+function pageOf(entries: readonly AgentEntry[], finished: boolean): Page {
   const first = entries[0]?.kind === 'prompt' ? entries[0] : undefined
   let rest = first ? entries.slice(1) : [...entries]
   const last = rest.at(-1)
   const answer = finished && last?.kind === 'text' ? last.text : undefined
   if (answer !== undefined) rest = rest.slice(0, -1)
-  const shown = rest.slice(-TALK_PAGE * (earlier + 1))
-  return { ...(first ? { first } : {}), hidden: rest.length - shown.length, shown, ...(answer !== undefined ? { answer } : {}) }
+  let room = TALK_CHARS - (first ? weight(first) : 0) - Math.min(answer?.length ?? 0, ANSWER_MAX)
+  let from = rest.length
+  while (from > 0 && room - weight(rest[from - 1]!) >= 0) room -= weight(rest[--from]!)
+  return { ...(first ? { first } : {}), dropped: from, shown: rest.slice(from), ...(answer !== undefined ? { answer } : {}) }
 }
 
 // ---- Desktop: the cards ------------------------------------------------------------------------
@@ -208,9 +221,23 @@ function timeCh(lang: Frame['lang']): number {
   return ch
 }
 
+/** Cells "failed" takes before the time when it failed. */
+function failedCells(frame: Frame, agent: AgentRec): number {
+  return agent.state === 'failed' ? Math.ceil(chOf(t(frame.lang, 'agents.failed'))) + 1 : 0
+}
+
 /** Cells of the time's column: the elapsed time's widest, and "failed" before it when it failed. */
 export function timeCells(frame: Frame, agent: AgentRec): number {
-  return Math.ceil(timeCh(frame.lang)) + (agent.state === 'failed' ? Math.ceil(chOf(t(frame.lang, 'agents.failed'))) + 1 : 0)
+  return Math.ceil(timeCh(frame.lang)) + failedCells(frame, agent)
+}
+
+/**
+ * Cells the time needs at the end of the numbers' last row: an hour's worth ("59분 59초"). It ends the
+ * row right-aligned, so a longer one only grows leftward into the row's slack; reserving 99 hours there
+ * left the time a row of its own on a narrow pane (2026-10-20).
+ */
+function tailCells(frame: Frame, agent: AgentRec): number {
+  return Math.ceil(chOf(elapsed(3_599_000, frame.lang))) + failedCells(frame, agent)
 }
 
 /** The widest each number shows, for its slot. */
@@ -245,17 +272,18 @@ const NARROW_CELLS = 44
 /**
  * How a card lays out, from the pane's width and its language alone, never a value that ticks.
  * Wide: the time and the chevron in a fixed column right of the title, the four numbers in a row.
- * Narrow (or when the four numbers would not fit a row): the title has the row to itself but for the
- * chevron, the numbers go in two fixed rows (in · cache / out · tools), and the time ends the second
- * of them, or takes a row of its own when it does not fit there.
+ * Narrow (or when the four numbers would not fit a row): the numbers go in two fixed rows (in · cache /
+ * out · tools) and the time ends the second of them; the title has its row to itself but for the
+ * chevron, or, when the time does not fit by the numbers, beside the time in the head. The time never
+ * takes a row of its own (2026-10-20: a whole row for one value was the owner's complaint).
  */
-type CardLayout = { width: number; narrow: boolean; time: number; timeOn: 'head' | 'nums' | 'own'; side: number; title: number }
+type CardLayout = { width: number; narrow: boolean; time: number; timeOn: 'head' | 'nums'; side: number; title: number }
 function layoutOf(frame: Frame, agent: AgentRec, pressable: boolean): CardLayout {
   const width = innerCells(frame)
   const figs = cardFigures(frame, agent)
   const narrow = width < NARROW_CELLS || figureCells(figs) > width - 2
   const time = timeCells(frame, agent)
-  const timeOn = !narrow ? 'head' : figs.length && figureCells(figs.slice(2)) + 2 + time <= width - 2 ? 'nums' : 'own'
+  const timeOn = narrow && figs.length && figureCells(figs.slice(2)) + 2 + tailCells(frame, agent) <= width - 2 ? 'nums' : 'head'
   const side = timeOn === 'head' ? time + (pressable ? 2 : 0) : pressable ? 1 : 0
   return { width, narrow, time, timeOn, side, title: width - 2 - (side ? side + 1 : 0) }
 }
@@ -285,14 +313,24 @@ function modelRow(frame: Frame, agent: AgentRec, model: string): { type: string;
   return { type, word, room: modelRoom(frame, agent, type, word) }
 }
 
+/** Lines a card's title takes at most; the rest is cut with an ellipsis. */
+const TITLE_LINES = 2
+
+/**
+ * The title cut to two lines of `cells`: a few cells short of two full ones, as wrapping at words
+ * leaves the end of a line empty.
+ */
+function cardTitle(agent: AgentRec, cells: number): string {
+  return clipCh(titleOf(agent), TITLE_LINES * Math.max(10, cells) - 4)
+}
+
 /** Rows a card draws, about: for the presses laid over it and the capsule's water. */
 export function cardRows(frame: Frame, agent: AgentRec, pressable = true): number {
   const layout = layoutOf(frame, agent, pressable)
-  const head = linesOf(titleOf(agent), layout.title)
+  const head = Math.min(TITLE_LINES, linesOf(cardTitle(agent, layout.title), layout.title))
   const nums = figureRows(cardFigures(frame, agent), layout.narrow).length
-  const own = layout.timeOn === 'own' ? 1 : 0
   const fall = agent.pick?.fallbackReason ? linesOf(t(frame.lang, 'agents.fallback', { reason: agent.pick.fallbackReason }), layout.width - 2) : 0
-  return head + 1.2 + nums + own + fall + 1.3
+  return head + 1.2 + nums + fall + 1.3
 }
 
 /** A state's mark and its colour: running in the accent, waiting amber, done green, failed red. */
@@ -338,8 +376,10 @@ function cardBody(el: Els, frame: Frame, agent: AgentRec, now: number, pressable
   const { type, word, room } = modelRow(frame, agent, model)
   const nums = figureRows(cardFigures(frame, agent), layout.narrow)
   const auto = agent.pick && ['haiku', 'jev', 'model'].includes(agent.pick.by)
+  // In the head a column as wide as its widest value; at the end of the numbers, right-aligned in
+  // the row's slack (layoutOf), as wide as it is.
   const time = (
-    <Box key="time" flexDirection="row" justifyContent="flex-end" columnGap={1} flexShrink={0} width={layout.time}>
+    <Box key="time" flexDirection="row" justifyContent="flex-end" columnGap={1} flexShrink={0} {...(layout.timeOn === 'head' ? { width: layout.time } : {})}>
       {agent.state === 'failed' ? <Text key="failed" color={k.tone('red')}>{t(L, 'agents.failed')}</Text> : null}
       <Text key="elapsed" {...(live(agent) ? k.ink : k.sub)}>{ranFor(agent, now, L)}</Text>
     </Box>
@@ -350,7 +390,7 @@ function cardBody(el: Els, frame: Frame, agent: AgentRec, now: number, pressable
         <Text color={m.color} bold>{m.glyph}</Text>
       </Box>
       <Box key="title" flexGrow={1} flexShrink={1} minWidth={0}>
-        <Text bold {...k.ink} wrap="wrap">{titleOf(agent)}</Text>
+        <Text bold {...k.ink} wrap="wrap">{cardTitle(agent, layout.title)}</Text>
       </Box>
       {layout.side ? (
         <Box key="side" flexDirection="row" justifyContent="flex-end" columnGap={1} flexShrink={0} width={layout.side}>
@@ -396,13 +436,6 @@ function cardBody(el: Els, frame: Frame, agent: AgentRec, now: number, pressable
       </Box>,
     )
   })
-  if (layout.timeOn === 'own') {
-    rows.push(
-      <Box key="time-row" flexDirection="row" justifyContent="flex-end" paddingLeft={2} minWidth={0}>
-        {time}
-      </Box>,
-    )
-  }
   if (agent.pick?.fallbackReason) {
     rows.push(
       <Box key="fallback" paddingLeft={2} minWidth={0}>
@@ -631,7 +664,7 @@ function block(el: Els, frame: Frame, key: string, label: RenderNode, text: stri
 
 /** The conversation under the card: the task, the latest entries, the answer, what it does now. */
 function talkDrawn(el: Els, frame: Frame, view: AgentsView, agent: AgentRec, talk: AgentTalk, actions: AgentsActions): RenderNode {
-  const { Box, Button, Markdown, Text } = el
+  const { Box, Markdown, Text } = el
   const k = pageLook(frame)
   const L = frame.lang
   if ('deny' in talk) {
@@ -641,13 +674,13 @@ function talkDrawn(el: Els, frame: Frame, view: AgentsView, agent: AgentRec, tal
       </Box>
     )
   }
-  const page = pageOf(talk.entries, view.open?.earlier ?? 0, !live(agent))
+  const page = pageOf(talk.entries, !live(agent))
   const items: RenderNode[] = []
   if (page.first?.kind === 'prompt') items.push(block(el, frame, 'task', <Text key="task-label" bold {...k.sub}>{t(L, 'agents.task')}</Text>, cut(page.first.text, PROMPT_MAX)))
-  if (page.hidden > 0) {
+  if (page.dropped > 0) {
     items.push(
-      <Box key="earlier" flexDirection="row" justifyContent="center">
-        <Button key="earlier" plain dimColor label={t(L, 'agents.earlier', { count: Math.min(page.hidden, TALK_PAGE) })} onPress={() => actions.earlier()} />
+      <Box key="dropped" flexDirection="row" justifyContent="center">
+        <Text {...k.mute}>{t(L, 'agents.dropped', { count: page.dropped })}</Text>
       </Box>,
     )
   }
@@ -728,14 +761,26 @@ function openDrawn(el: Els, frame: Frame, view: AgentsView, actions: AgentsActio
       card(el, frame, agent, view.now),
     ],
   })
+  // Scrolled past the head, the way back floats at the window's top: the engine asks again with the
+  // new offset on each scroll, so a box placed at that row stays put while the conversation moves
+  // under it. Scrolling back up to leave was the owner's complaint (2026-10-20).
+  const offset = frame.offset ?? 0
   return (
-    <Box flexDirection="column" rowGap={1} width="100%" minWidth={0}>
+    <Box position="relative" flexDirection="column" rowGap={1} width="100%" minWidth={0}>
       {head}
       {talkDrawn(el, frame, view, agent, talk, actions)}
+      {offset >= FLOAT_AFTER ? (
+        <Box key="float-back" position="absolute" top={offset} left={0} flexDirection="row" paddingLeft={1}>
+          {pill(el, frame, 'back-float', t(L, 'agents.back'), 'primary', actions.back, 'violet', 'back')}
+        </Box>
+      ) : null}
     </Box>
   )
 }
 
+/** Rows scrolled before the way back floats: about where the head's own leaves the window. */
+const FLOAT_AFTER = 3
+
 // ---- Terminal ----------------------------------------------------------------------------------
 
 /** The model line as text: the model, its effort, its type when that says more. */
@@ -842,9 +887,9 @@ function openText(el: Els, frame: Frame, view: AgentsView, actions: AgentsAction
   const lines: RenderNode[] = []
   if ('deny' in talk) lines.push(<Text key="deny" dimColor wrap="wrap">{t(L, 'agents.deny', { reason: talk.deny })}</Text>)
   else {
-    const page = pageOf(talk.entries, view.open?.earlier ?? 0, !live(agent))
+    const page = pageOf(talk.entries, !live(agent))
     if (page.first?.kind === 'prompt') lines.push(<Box key="task" flexDirection="column"><Text dimColor>{t(L, 'agents.task')}</Text><Text wrap="wrap">{cut(page.first.text, 600)}</Text></Box>)
-    if (page.hidden > 0) lines.push(<Box key="earlier">{textButton(el, 'earlier', t(L, 'agents.earlier', { count: Math.min(page.hidden, TALK_PAGE) }), actions.earlier, 'e')}</Box>)
+    if (page.dropped > 0) lines.push(<Box key="dropped"><Text dimColor>{t(L, 'agents.dropped', { count: page.dropped })}</Text></Box>)
     // A run of calls folds into one line here too; a single call, and the one in flight, stay lines.
     const inFlight = live(agent) ? page.shown.findLast(e => e.kind === 'tool' && e.state === 'running') : undefined
     const opened = view.open?.runsOpen ?? []

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

@@ -16,6 +16,8 @@ export type Frame = {
   columns: number
   /** Rows the band may take (`maxRows`); a pane passes its `scroll.bodyRows`. */
   maxRows: number
+  /** A pane's first row in view (`scroll.offset`); the engine asks again when the person scrolls. */
+  offset?: number
   /** Epoch ms when drawn; countdowns are computed from it. */
   now: number
   appearance: Appearance
@@ -222,8 +224,8 @@ export type AgentsView = {
   now: number
   /** Every finished agent, not only the latest few. */
   showDone: boolean
-  /** The agent whose conversation is open, what of it was read, and how many earlier pages show. */
-  open?: { id: string; talk: AgentTalk; earlier: number; runsOpen?: readonly string[] }
+  /** The agent whose conversation is open, what of it was read, and the runs of calls unfolded. */
+  open?: { id: string; talk: AgentTalk; runsOpen?: readonly string[] }
 }
 
 export type AgentsActions = {
@@ -232,8 +234,6 @@ export type AgentsActions = {
   open: (id: string) => void
   /** Back to the list. */
   back: () => void
-  /** One more page of the open conversation's earlier entries. */
-  earlier: () => void
   /** Folds or unfolds a run of tool calls, named by its first call's id. */
   toggleRun: (id: string) => void
 }
@@ -312,8 +312,11 @@ export function cachePercent(usage: Usage | undefined): number | undefined {
 export function modelOf(record: StatusRequest): string {
   const at = record.source.lastIndexOf('@')
   const source = at < 0 ? record.source : record.source.slice(0, at)
+  // A hosted id's vendor path ("deepseek-ai/") goes, as on the agent cards: the slot is narrow and
+  // the provider is named beside it.
+  const bare = (id: string) => id.replace(/^.*\//, '')
   // A dated id of the same model (claude-haiku-5-5-20260815 for claude-haiku-5-5) says nothing new.
-  return source.startsWith(record.target) || record.target.startsWith(source) ? record.target : record.target + ' (' + source + ')'
+  return source.startsWith(record.target) || record.target.startsWith(source) ? bare(record.target) : bare(record.target) + ' (' + bare(source) + ')'
 }
 
 export function routeOf(record: StatusRequest): RouteView {

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

@@ -131,6 +131,9 @@ test('view helpers', () => {
   expect(targetOf('gpt-6-1-sol')).toEqual({ agent: 'gpt-6-1-sol' })
   const record: StatusRequest = { at: '2026-10-10T13:19:10', source: 'gpt-6-1-sol@high', target: 'gpt-6.1-sol', provider: 'chatgpt', status: 200, ok: true, ms: 2140, usage: { input: 3000, cached: 41_000, output: 900 } }
   expect(routeOf(record)).toMatchObject({ model: 'gpt-6.1-sol (gpt-6-1-sol)', cachePct: 93, seconds: 2.14 })
+  // A hosted id's vendor path is not drawn.
+  expect(routeOf({ ...record, source: 'deepseek-ai-deepseek-v4-1-flash-1017@high', target: 'deepseek-ai/deepseek-v4.1-flash-1017' }).model).toBe('deepseek-v4.1-flash-1017 (deepseek-ai-deepseek-v4-1-flash-1017)')
+  expect(routeOf({ ...record, source: 'deepseek-ai/deepseek-v4.1-flash-1017', target: 'deepseek-ai/deepseek-v4.1-flash-1017' }).model).toBe('deepseek-v4.1-flash-1017')
   expect(minutesLeft(41 * 60_000 + 1, 'en')).toBe('42m')
   expect(minutesLeft(41 * 60_000, 'en')).toBe('41m')
   expect(minutesLeft(30_000, 'ko')).toBe('1분')
@@ -586,7 +589,7 @@ const AGENTS: AgentRec[] = [
   { id: 'a2', description: 'Summarize the docs', type: 'deepseek-v4-1-flash', state: 'done', startedAt: NOW - 900_000, endedAt: NOW - 800_000, cost: 9000 },
 ]
 
-const AGENT_NOOP: AgentsActions = { toggleDone: () => undefined, open: () => undefined, back: () => undefined, earlier: () => undefined, toggleRun: () => undefined }
+const AGENT_NOOP: AgentsActions = { toggleDone: () => undefined, open: () => undefined, back: () => undefined, toggleRun: () => undefined }
 
 test('the Agents pane draws a worker the session\'s own model runs', async ($, on) => {
   const onSession: AgentRec = { ...AGENTS[0]!, id: 's1', description: 'Review on the session model', pick: { ...AGENTS[0]!.pick!, target: { agent: 'general-purpose' }, by: 'session' } }
@@ -653,7 +656,7 @@ test('the Agents pane shows the latest finished agents and the rest behind more;
 
 test('an agent\'s conversation reads in the pane: the task, its words, its tools, the answer, and a way back', async ($, on) => {
   const { calls, fn } = recorder()
-  const actions = { ...AGENT_NOOP, back: fn('back'), earlier: fn('earlier') }
+  const actions = { ...AGENT_NOOP, back: fn('back') }
   const talk: AgentEntry[] = [
     { kind: 'prompt', text: 'Port the log renderer to the new kit.' },
     { kind: 'text', text: 'Reading the **current** renderer first.' },
@@ -663,11 +666,13 @@ test('an agent\'s conversation reads in the pane: the task, its words, its tools
   ]
   const done: AgentRec = { ...AGENTS[0]!, id: 'a9', state: 'done', endedAt: NOW - 1000, now: undefined, toolSince: undefined }
   const long: AgentEntry[] = [talk[0]!, ...Array.from({ length: 45 }, (_, i): AgentEntry => ({ kind: 'tool', id: 'x' + i, tool: 'Grep', detail: 'pattern ' + i, state: 'ok' }))]
-  drawPane(on, 'talk-live', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: talk }, earlier: 0 } }, actions))
-  drawPane(on, 'talk-done', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: [...talk.slice(0, 3), { kind: 'text', text: 'Ported; tests pass.' }] }, earlier: 0 } }, actions))
-  drawPane(on, 'talk-long', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: long }, earlier: 0, runsOpen: ['x15'] } }, actions))
-  drawPane(on, 'talk-deny', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { deny: 'no saved transcript for a1' }, earlier: 0 } }, actions))
-  drawPane(on, 'talk-gone', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'zz', talk: { entries: [] }, earlier: 0 } }, actions))
+  drawPane(on, 'talk-live', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: talk } } }, actions))
+  drawPane(on, 'talk-done', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: [...talk.slice(0, 3), { kind: 'text', text: 'Ported; tests pass.' }] } } }, actions))
+  drawPane(on, 'talk-long', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: long }, runsOpen: ['x0'] } }, actions))
+  const huge: AgentEntry[] = [talk[0]!, ...Array.from({ length: 60 }, (_, i): AgentEntry => ({ kind: 'text', text: 'words ' + i + ' ' + 'x'.repeat(2000) }))]
+  drawPane(on, 'talk-huge', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: huge } } }, actions))
+  drawPane(on, 'talk-deny', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { deny: 'no saved transcript for a1' } } }, actions))
+  drawPane(on, 'talk-gone', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: AGENTS, now: NOW, showDone: false, open: { id: 'zz', talk: { entries: [] } } }, actions))
   for (const surface of SURFACES) {
     const live = await mount($, 'talk-live', surface, 64)
     expect(await live.find({ type: 'Text', text: 'Port the request log renderer' }), surface).toBeDefined()
@@ -685,17 +690,40 @@ test('an agent\'s conversation reads in the pane: the task, its words, its tools
     const finished = await mount($, 'talk-done', surface, 64)
     expect(await finished.find({ type: 'Text', text: 'Final answer' }), surface).toBeDefined()
     const long_ = await mount($, 'talk-long', surface, 64)
-    // The task stays at the head; 30 of the 45 calls show, 15 wait behind "earlier".
+    // Every entry shows, as in the Claude app's chat: no "earlier" to press.
     expect(await long_.find({ type: 'Text', text: 'pattern 44' }), surface).toBeDefined()
-    expect(await long_.find({ type: 'Text', text: 'pattern 14' }), surface).toBeUndefined()
-    await long_.press({ key: 'earlier' })
+    expect(await long_.find({ type: 'Text', text: 'pattern 0' }), surface).toBeDefined()
+    expect(await long_.find({ key: 'earlier' }), surface).toBeUndefined()
+    expect(await long_.find({ key: 'dropped' }), surface).toBeUndefined()
+    // Only a conversation past what a tree can draw loses its oldest entries, and says so.
+    const huge = await mount($, 'talk-huge', surface, 64)
+    expect(await huge.find({ key: 'dropped' }), surface).toBeDefined()
+    const latest = surface === 'desktop'
+      ? (await huge.findAll({ type: 'Markdown' })).some(m => String(m.props.text).startsWith('words 59'))
+      : (await huge.find({ type: 'Text', text: /^words 59/ })) !== undefined
+    expect(latest, surface).toBe(true)
     const deny = await mount($, 'talk-deny', surface, 64)
     expect(await deny.find({ type: 'Text', text: /can’t be read: no saved transcript for a1/ }), surface).toBeDefined()
     const gone = await mount($, 'talk-gone', surface, 64)
     expect(await gone.find({ type: 'Text', text: 'This agent is no longer in the list.' }), surface).toBeDefined()
     await gone.press({ key: 'back' })
   }
-  expect(calls).toEqual(['back', 'earlier', 'back', 'back', 'earlier', 'back'])
+  expect(calls).toEqual(['back', 'back', 'back', 'back'])
+})
+
+test('scrolled down an open conversation, the way back floats at the window\'s top', async ($, on) => {
+  const { calls, fn } = recorder()
+  const actions = { ...AGENT_NOOP, back: fn('back') }
+  const talk: AgentEntry[] = [{ kind: 'prompt', text: 'Do it.' }, ...Array.from({ length: 20 }, (_, i): AgentEntry => ({ kind: 'text', text: 'words ' + i }))]
+  const view = { agents: AGENTS, now: NOW, showDone: false, open: { id: 'a1', talk: { entries: talk } } }
+  drawPane(on, 'float-top', el => renderAgents(el, frameOf('desktop', 64), view, actions))
+  drawPane(on, 'float-down', el => renderAgents(el, { ...frameOf('desktop', 64), offset: 12 }, view, actions))
+  const top = await mount($, 'float-top', 'desktop', 64)
+  expect(await top.find({ key: 'float-back' })).toBeUndefined()
+  const down = await mount($, 'float-down', 'desktop', 64)
+  expect((await down.find({ key: 'float-back' }))?.props.top).toBe(12)
+  await down.press({ key: 'back-float' })
+  expect(calls).toEqual(['back'])
 })
 
 test('talkOf reads a conversation into prompts, words and tool calls that stand answered, failed or running', () => {
@@ -1189,8 +1217,8 @@ test('a run of calls folds into its head, unfolds call by call when pressed, and
     { kind: 'tool', id: 'solo', tool: 'Bash', detail: 'git status', state: 'ok' },
   ]
   const done: AgentRec = { ...AGENTS[0]!, id: 'a9', state: 'done', endedAt: NOW - 1000, now: undefined, toolSince: undefined }
-  drawPane(on, 'runs-folded', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: talk }, earlier: 0 } }, actions))
-  drawPane(on, 'runs-open', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: talk }, earlier: 0, runsOpen: ['b0'] } }, actions))
+  drawPane(on, 'runs-folded', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: talk } } }, actions))
+  drawPane(on, 'runs-open', (el, surface) => renderAgents(el, frameOf(surface, 64), { agents: [done], now: NOW, showDone: false, open: { id: 'a9', talk: { entries: talk }, runsOpen: ['b0'] } }, actions))
   for (const surface of SURFACES) {
     const folded = await mount($, 'runs-folded', surface, 64)
     expect(await folded.find({ type: surface === 'desktop' ? 'Text' : 'Button', text: /^Ran 8 commands, Edited 1 file/ }), surface).toBeDefined()
@@ -1292,4 +1320,9 @@ test('a narrow card keeps its model on one line without the vendor path, and its
   expect(await narrow.find({ key: 'nums-1' })).toBeDefined()
   expect(await wide.find({ key: 'nums-1' })).toBeUndefined()
   expect(await narrow.find({ type: 'Text', text: '3m 12s' }) ?? await narrow.find({ type: 'Text', text: '3분 12초' })).toBeDefined()
+  // The time never takes a row of its own, and a long title is cut to two lines.
+  for (const ui of [narrow, wide]) expect(await ui.find({ key: 'time-row' })).toBeUndefined()
+  const title = (await narrow.find({ type: 'Text', text: /^Port the/ }))!.text
+  expect(title.endsWith('…')).toBe(true)
+  expect(chOf(title) <= 2 * 33).toBe(true)
 })

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

@@ -400,8 +400,6 @@ declare module 'claude-code' {
       agentsShowDone: boolean
       /** The agent whose conversation the Agents pane shows; null shows the list. */
       agentOpen: string | null
-      /** Pages of earlier entries the open conversation shows beyond its latest. */
-      agentEarlier: number
       /** The open conversation's tool runs shown call by call, by their first call's id. */
       agentRunsOpen: string[]
       /** Counts the Agents pane's seconds while an agent runs: a write redraws its clocks. */

package/dist/remote/src/bridge-client.js

@@ -22,20 +22,61 @@ export const AUTH_REREAD_MS = 30_000;
 export function object(value) {
     return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
 }
+/** A Claude app login the router saw this long ago still counts as current. */
+export const OBSERVED_FRESH_MS = 6 * 3_600_000;
+/** How long an observed login is trusted before it is read again (its own expiry is not visible). */
+export const OBSERVED_TTL_MS = 10 * 60_000;
+/**
+ * The login the Claude app itself is using right now, as the router last saw it on a request it
+ * carried (router observedClaudeCodeAuth, `claude-auth-observed.json`), or null when there is none
+ * recent. The keychain item belongs to the `claude` CLI and is refreshed only while the CLI runs:
+ * working in the desktop app alone left it expired, then emptied (accessToken "", expiresAt 0,
+ * 2026-10-20 21:28), and the phone was told the login had expired while the app worked fine.
+ */
+export function loadObservedAuth(now = Date.now(), home = process.env.CLAUDERIPPLE_HOME ?? path.join(os.homedir(), ".clauderipple")) {
+    try {
+        const seen = object(JSON.parse(fs.readFileSync(path.join(home, "claude-auth-observed.json"), "utf8")));
+        const token = typeof seen?.authorization === "string" ? /^Bearer\s+(\S+)$/.exec(seen.authorization)?.[1] : undefined;
+        if (!token || typeof seen?.observedAt !== "number" || now - seen.observedAt > OBSERVED_FRESH_MS)
+            return null;
+        return { accessToken: token, expiresAt: now + OBSERVED_TTL_MS };
+    }
+    catch {
+        return null;
+    }
+}
 export function loadBridgeAuth() {
     if (process.platform !== "darwin")
         throw new Error(DESKTOP_BLOCKED);
+    const now = Date.now();
+    let organizationUuid;
     try {
-        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
-        const oauth = object(credentials?.claudeAiOauth);
         const account = object(object(JSON.parse(fs.readFileSync(path.join(os.homedir(), ".claude.json"), "utf8")))?.oauthAccount);
-        if (typeof oauth?.accessToken !== "string" || typeof oauth.expiresAt !== "number" || typeof account?.organizationUuid !== "string")
+        if (typeof account?.organizationUuid !== "string")
             throw new Error();
-        return { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt, organizationUuid: account.organizationUuid };
+        organizationUuid = account.organizationUuid;
     }
     catch {
         throw new BridgeAuthError("이 컴퓨터의 Claude 로그인 정보를 읽을 수 없습니다.");
     }
+    let keychain = null;
+    try {
+        const credentials = object(JSON.parse(execFileSync("security", ["find-generic-password", "-a", process.env.USER ?? os.userInfo().username, "-s", "Claude Code-credentials", "-w"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] })));
+        const oauth = object(credentials?.claudeAiOauth);
+        if (typeof oauth?.accessToken === "string" && oauth.accessToken && typeof oauth.expiresAt === "number")
+            keychain = { accessToken: oauth.accessToken, expiresAt: oauth.expiresAt };
+    }
+    catch { /* the observed login may still serve */ }
+    // The CLI's login while it is good; else the one the Claude app is working with; else the
+    // CLI's expired one, so the phone is told it expired.
+    if (keychain && keychain.expiresAt - now > 5 * 60_000)
+        return { ...keychain, organizationUuid };
+    const observed = loadObservedAuth(now);
+    if (observed)
+        return { ...observed, organizationUuid };
+    if (keychain)
+        return { ...keychain, organizationUuid };
+    throw new BridgeAuthError(LOGIN_EXPIRED);
 }
 /** `slash_commands` minus `terminal_slash_commands`, which phone UIs should hide (SDK init docs). */
 export function slashCommands(init) {