jevmate

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    if (cfg.bandMode === 'off' || e.props.hasSurvey) return next(e)
    const { Box, Button, Text } = $.ui.resolve(e)
    const theirs = await next(e) // what other mods draw here stays, under ours
    const j = summary?.jev
    if (collapsed) {
      const five = summary?.plan?.windows?.five_hour?.kept_free ?? summary?.plan?.windows?.seven_day?.kept_free
      const worth = j && !isIdle(j) && savedTotal(j) >= MONEY_FLOOR
      const first = j && !isIdle(j) ? caught(j)[0] : undefined
      const down = failing(j)
      const chip: Piece[] = down
        ? [{ text: ' ' }, down[0]]
        : !j || isIdle(j)
          ? [{ text: ' ready', dim: true }]
          : worth && five !== null && five !== undefined
            ? [{ text: ` ${points(five)} of ${summary?.plan?.windows?.five_hour?.kept_free !== undefined && summary?.plan?.windows?.five_hour?.kept_free !== null ? '5h' : 'the week'} saved`, color: GOOD }]
            : worth
              ? [{ text: ` ~${money(savedTotal(j))} saved`, color: GOOD }]
              : first
                ? [{ text: ' ' }, ...first]
                : [{ text: ` ${k(j.kept_out)} tokens kept out`, dim: true }]
      return (
        <Box flexDirection="column">
          <Box flexDirection="row">
            {spans(Text, [{ text: '◆ jev', bold: true, color: ACCENT }, ...chip, { text: '  ' }], 'truncate-end')}
            <Button key="show" label="show" plain dimColor onPress={() => setCollapsed($, false)} />
          </Box>
          {theirs}
        </Box>
      )
    }
    // Cells are counted for a monospace grid; the desktop's proportional font fits about a fifth more text in them.
    const room = Math.max(24, Math.floor((e.props.bodyColumns - 26) * (e.surface === 'desktop' ? 1.2 : 1)))
    const pieces: Piece[] = [{ text: '◆ jev', bold: true, color: ACCENT }, { text: '  ' }]
    fit(segments(), room).forEach((seg, i) => {
      if (i) pieces.push({ text: ' · ', dim: true })
      pieces.push(...seg.pieces)
    })
    pieces.push({ text: '   ' })
    return (
      <Box flexDirection="column">
        <Box flexDirection="row">
          {spans(Text, pieces, 'truncate-end')}
          <Button key="details" label="details" plain onPress={() => void openPane($).catch(() => undefined)} />
          <Text dimColor> · </Text>
          <Button key="hide" label="hide" plain dimColor onPress={() => setCollapsed($, true)} />
        </Box>
        {theirs}
      </Box>
    )
  })

function spans(Text: El, pieces: Piece[], wrap?: 'truncate-end') {
  return (
    <Text {...(wrap ? { wrap } : {})}>
      {pieces.map(p => (
        <Text {...style(p)}>{p.text}</Text>
      ))}
    </Text>
  )
}

  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
    const { Box, Button, Text } = $.ui.resolve(e)
    const terminal = e.surface === 'terminal' // bars need a monospace grid; the desktop's font is proportional
    const j = summary?.jev
    const project = summary?.cwd ? summary.cwd.split('/').filter(Boolean).pop() : ''
    const row = (label: string, pieces: Piece[]) => (
      <Box flexDirection="row">
        <Box width={LABEL} flexShrink={0}>
          <Text dimColor>{label}</Text>
        </Box>
        <Box flexGrow={1} flexShrink={1}>
          {spans(Text, pieces)}
        </Box>
      </Box>
    )
    const header = spans(Text, [
      { text: '◆ jev', bold: true, color: ACCENT },
      { text: ` · this session${project ? ` · ${project}` : ''}${refreshedAt ? ` · ${refreshedAt}` : ''}`, dim: true },
    ])
    const controls = (
      <Box flexDirection="row" columnGap={2}>
        <Button key="toggle" label={collapsed ? 'show the line above the prompt' : 'fold the line above the prompt'} onPress={() => setCollapsed($, !collapsed)} />
        <Button key="refresh" label="refresh" onPress={() => void refresh($)} />
        <Button key="close" label="close" role="dismiss" onPress={() => void $.ui.close({ id: PANE }).catch(() => undefined)} />
      </Box>
    )
    if (isIdle(j) || !j) {
      return (
        <Box flexDirection="column">
          {header}
          <Text> </Text>
          <Text dimColor>{summary ? 'Nothing went through jev yet this session. `jev sift`, `jev tests` and the hooks show up here.' : 'reading the session…'}</Text>
          <Text> </Text>
          {controls}
        </Box>
      )
    }
    const s = spent()
    const total = savedTotal(j)
    const share = s ? Math.min(1, total / s.usd) : null
    const bar = Math.max(10, Math.min(36, e.props.bodyColumns - LABEL - 8))
    const top = (labels: Record<string, number> | undefined, count: number) =>
      Object.entries(labels ?? {})
        .slice(0, count)
        .map(([name, tokens]) => `${name} ${k(tokens)}`)
        .join(' · ')
    const plan = summary?.plan?.windows
    // A plan window: what is used, then what the kept-out text would have taken on top of it (a bar on the terminal).
    const windowRow = (kind: string, w: PlanWindow) => {
      const used = Math.min(bar, Math.round((w.used / 100) * bar))
      const kept = w.kept_free === null ? 0 : Math.min(bar - used, Math.max(w.kept_free > 0 ? 1 : 0, Math.round((w.kept_free / 100) * bar)))
      const tone = w.used >= 80 ? { color: BAD } : w.used >= 60 ? { color: WARN } : { color: INFO }
      const meter: Piece[] = terminal
        ? [{ text: '█'.repeat(used), ...tone }, { text: '█'.repeat(kept), color: GOOD }, { text: `${'░'.repeat(bar - used - kept)} `, dim: true }]
        : []
      return row(w.label || kind, [
        ...meter,
        { text: `${Math.round(w.used)}% used`, bold: true, ...tone },
        w.kept_free === null ? { text: ' · measuring what a dollar of use takes', dim: true } : { text: ` · jev kept ${points(w.kept_free)} free`, color: GOOD },
        { text: `${resets(w.resets_at, kind !== 'five_hour')}${w.as_of ? ` · as of ${w.as_of}` : ''}`, dim: true },
      ])
    }
    const sf = caught(j)
    const ro = j.routing
    const sub = summary?.subagents
    const filled = share === null ? 0 : Math.round(share * bar)
    const trimOn = cfg.trimMode !== 'off'
    const subagentOn = cfg.subagentModel === 'sonnet' || cfg.subagentModel === 'haiku'
    const effortOn = cfg.routeMode === 'effort'
    const compactOn = cfg.compactMode === 'on' || cfg.compactMode === 'auto'
    const co = j.compact
    const models = sub ? Object.entries(sub.models).map(([m, count]) => `${count} on ${shortModel(m)}`).join(', ') : ''
    const down = failing(j)
    return (
      <Box flexDirection="column">
        {header}
        <Text> </Text>
        {down && j.api
          ? row('jev', [
              { text: "can't judge", bold: true, color: BAD },
              {
                text: ` · ${j.api.reason}${j.api.since ? ` since ${clock(j.api.since)}` : ''} · the hooks let everything through unchecked · jev doctor checks the key and the backend`,
                dim: true,
              },
            ])
          : null}
        {row('saved', [
          { text: `~${money(total)}`, bold: true, color: GOOD },
          { text: plan ? ' at most · a subscription is not billed per token, so this is an API equivalent' : ' at most', dim: true },
          ...(!plan && share !== null && s ? [{ text: ` · ${pct(share)} of the session's ${s.estimated ? '~' : ''}${money(s.usd)}`, dim: true } as Piece] : []),
        ])}
        {!plan && share !== null && s && terminal
          ? row('', [{ text: '█'.repeat(filled), color: GOOD }, { text: '░'.repeat(bar - filled), dim: true }])
          : null}
        {row('  reading', [
          { text: `~${money(j.saved)}`, color: GOOD },
          { text: ` · ${k(j.reads ?? j.kept_out)} tokens judged by jev instead of read · ${money(j.once ?? j.would)} once, ${money(j.reread ?? 0)} re-read until the next compaction`, dim: true },
        ])}
        {row('  trim', [
          { text: trimOn ? 'on' : 'off', bold: true, ...(trimOn ? { color: GOOD } : {}) },
          j.trimmed
            ? { text: ` · ${k(j.trimmed)} tokens of command output kept out in ${plural(j.trim_runs, 'run')}`, dim: true }
            : { text: trimOn ? ' · no command output over ~4k tokens yet' : ' · long command output reaches the context whole', dim: true },
        ])}
        {row('  subagents', [
          { text: subagentOn ? `on, ${cfg.subagentModel}` : 'off', bold: true, ...(subagentOn ? { color: GOOD } : {}) },
          ro && ro.subagents
            ? { text: ` · ${plural(ro.subagents, 'subagent')} moved to a cheaper model · ~${money(ro.subagent_saved)} saved, from their own usage`, dim: true }
            : sub && sub.count
              ? sub.could_save >= 0.01
                ? { text: ` · ${plural(sub.count, 'subagent')} ran (${models}) · ~${money(sub.could_save)} less on Sonnet`, color: WARN }
                : { text: ` · ${plural(sub.count, 'subagent')} ran (${models}) · nothing to gain from a cheaper model`, dim: true }
              : { text: ' · no subagents this session', dim: true },
        ])}
        {row('  low effort', [
          { text: effortOn ? 'on' : 'off', bold: true, ...(effortOn ? { color: GOOD } : {}) },
          {
            text:
              ro && ro.effort_turns
                ? ` · ${plural(ro.effort_turns, 'routine turn')}${ro.effort_cache === 'keeps' ? ' · the prompt cache survives it' : ro.effort_cache === 'rewrites' ? ' · it re-wrote the prompt cache, so it stopped' : ''}`
                : effortOn
                  ? effortCache === 'rewrites'
                    ? ' · stopped: lowering effort re-writes the prompt cache on this build'
                    : ' · waits for a routine prompt on a context under 100k tokens to check the cache'
                  : ' · routine turns run at the session effort',
            dim: true,
          },
        ])}
        {row('  compaction', [
          { text: compactOn ? cfg.compactMode : 'off', bold: true, ...(compactOn ? { color: GOOD } : {}) },
          co && co.runs
            ? {
                text: ` · ${plural(co.runs, 'compaction')} judged · ${plural(co.moved, 'result')} moved to disk, ${n(co.cut)} cut · read again later: ${co.rereads}${co.saved_usd ? ` · ~${money(co.saved_usd)} off the summary` : ''}${autoLine(co.auto)}`,
                dim: true,
              }
            : {
                text: compactOn
                  ? cfg.compactMode === 'auto'
                    ? ` · compacts in the background above ${k(autoMin)} tokens of context: after ${Math.round(autoIdleMs / 60_000)} min idle, before the prompt cache expires, or once a prompt has started other work`
                    : compactCache === 'pays'
                    ? ' · at the next compaction the summarizer reads the conversation with stale results moved out'
                    : ' · at the next compaction, large results are judged and saved, and what the work needs comes back after the summary'
                  : ' · Claude Code summarizes on its own',
                dim: true,
              },
        ])}
        {plan ? Object.entries(plan).map(([kind, w]) => windowRow(kind, w)) : null}
        {plan && summary?.plan?.missing?.includes('five_hour')
          ? row('5-hour window', [{ text: 'no reading yet · Claude Code reports it with its next request', dim: true }])
          : null}
        {row(
          'safety',
          sf.length
            ? [
                ...sf.flatMap((p, i) => (i ? [{ text: ' · ', dim: true } as Piece, ...p] : p)),
                { text: ` · ${n(j.safety?.checks ?? 0)} checks`, dim: true },
              ]
            : [{ text: `nothing to flag · ${n(j.safety?.checks ?? 0)} checks`, dim: true }],
        )}
        {ctxPct !== null