leitstand

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    if (e.props.hasSurvey) return next(e)
    const th = await theme($)
    const all = await read($, jobs)
    const live = running(all)
    const ended = th === 'loud' ? all.filter(j => j.status !== 'running') : []
    const d = await read($, disk)
    const explicit = await read($, open)
    const isOpen = explicit ?? th === 'loud'
    const f = await read($, frame)
    const t = (await read($, now)) || (await $.clock.now())
    const hostName = await host($)
    const lv = level(d?.freeGb ?? null)
    const diskNeeds = needsYou(lv, await read($, diskSeen))
    const s = summary([...live, ...ended], diskNeeds)
    const g = await read($, block)
    const c0 = await read($, ctx)
    const c = c0 && typeof c0 === 'object' ? c0 : null
    const ctxHigh = c !== null && c.tokens >= CTX_SHOW
    const active = s.running + s.done + s.needs > 0 || !!g || ctxHigh
    if (!active && explicit !== true) return next(e)

    const { Box, Text } = $.ui.resolve(e)
    const loud = th === 'loud'
    const spin = SPIN[f % SPIN.length]
    const diskColor = lv === 'bad' ? C.bad : lv === 'warn' ? C.warn : C.clay

    // loud shows the disk whenever the list is up; quiet only once it runs low
    const diskShown = !!d && (d.pct === null ? !!d.error : loud || lv !== 'ok')
    const ctxShown = c !== null && (!loud || ctxHigh || explicit === true)
    const listCount = isOpen ? Math.max(live.length + ended.length, 1) + (diskShown ? 1 : 0) + (ctxShown ? 1 : 0) : 0
    const twoCols = listCount >= 4 && e.props.bodyColumns >= TWO_COLS_MIN
    const W = twoCols ? { label: 18, bar: 10, right: 6 } : { label: 24, bar: 14, right: 8 }
    const diskName = twoCols ? (hostName ?? 'disk') : hostName ? `${hostName} disk` : 'disk'

    const Track = ({ s: str }: { s: string }) => <Text color={C.track} dimColor>{str}</Text>
    const Hint = () => <Text dimColor>{'     /stand'}</Text>
    const Row = ({ mark, color, state, label, bar, right, bold, hint }: { mark: string; color: string; state: string; label: string; bar: unknown; right: string; bold?: boolean; hint?: boolean }) => (
      <Box>
        <Text color={color}>{mark} </Text>
        <Text color={color} bold={bold}>{fit(state, 11)}</Text>
        <Text>{fit(label, W.label)} </Text>
        {bar as never}
        <Text dimColor>{right.padStart(W.right)}</Text>
        {hint ? <Hint /> : null}
      </Box>
    )
    const empty = <Track s={(loud ? DOT : '─').repeat(W.bar)} />

    const jobRows = live.map((j, i) => {
      const [pre, comet, post] = (loud ? loudScanner : scanner)(f + i * 5, W.bar)
      const bar = [<Track s={pre} />, <Text color={C.clay}>{comet}</Text>, <Track s={post} />]
      return <Row mark={spin} color={C.clay} state="running" label={j.label} bar={bar} right={elapsed(t - j.startedAt)} />
    })
    const endedRows = ended.map(j => {
      if (j.status === 'done') {
        const [body] = loudMeter(100, W.bar)
        return <Row mark="✓" color={C.ok} state="done" label={j.label} bar={<Text color={C.ok}>{body}</Text>} right={elapsed((j.endedAt ?? t) - j.startedAt)} />
      }
      const [stub, track] = loudStub(W.bar)
      return <Row mark="!" color={C.bad} state="needs you" label={j.label} bar={[<Text color={C.bad}>{stub}</Text>, <Text color={C.bad} dimColor>{track}</Text>]} right="failed" bold />
    })

    // Seen means calm: no "needs you", just the numbers in the warning color
    const diskRow = (hint = false) => !d || !diskShown ? null : d.pct === null
      ? <Row mark=" " color={C.track} state="disk" label={d.error === INVALID_HOST ? 'invalid disk host' : hostName ? `${hostName} unreachable` : 'disk unreadable'} bar={empty} right="" />
      : (() => {
        const [body, rest] = (loud ? loudMeter : meter)(d.pct, W.bar)
        const bar = [<Text color={diskColor}>{body}</Text>, <Track s={rest} />]
        // Last measurement failed: the old value stays, marked as stale
        const diskRight = d.error ? 'stale' : `${d.pct} %`
        if (diskNeeds) return <Row mark="!" color={diskColor} state="needs you" label={`${diskName} · ${d.freeGb} GB free`} bar={bar} right={diskRight} bold hint={hint} />
        return <Row mark=" " color={diskColor} state={loud ? '' : 'disk'} label={`${loud ? diskName : hostName ?? 'disk'} · ${d.freeGb} GB free`} bar={bar} right={diskRight} />
      })()

    const ctxRow = (hint = false) => !ctxShown || !c ? null : (() => {
      const [body, rest] = (loud ? loudMeter : meter)(c.pct, W.bar)
      const color = ctxHigh ? C.warn : C.track
      return <Row mark=" " color={color} state={ctxHigh ? 'compact' : 'context'} label={`${kTok(c.tokens)} of ${kTok(c.window)}`} bar={[<Text color={color}>{body}</Text>, <Track s={rest} />]} right={`${c.pct} %`} hint={hint} />
    })()

    const idle = <Row mark="·" color={C.track} state="idle" label="nothing running" bar={empty} right="" />
    const openRows = isOpen ? [live.length + ended.length === 0 ? idle : null, ...jobRows, ...endedRows, diskRow(), ctxRow()].filter(Boolean) : []
    const half = Math.ceil(openRows.length / 2)
    const list = isOpen && (twoCols
      ? <Box columnGap={4}><Box flexDirection="column">{openRows.slice(0, half)}</Box><Box flexDirection="column">{openRows.slice(half)}</Box></Box>
      : openRows)

    const blockLine = (hint: boolean) => g && (
      <Box>
        <Text color={C.bad}>■ </Text>
        <Text bold>{g.hook}</Text>
        <Text dimColor>{' blocked'}</Text>
        {g.reason ? <Text dimColor>{`  ·  ${fit(g.reason, 60).trimEnd()}`}</Text> : null}
        {hint ? <Hint /> : null}
      </Box>
    )

    if (loud) {
      // The footer counts everything, folded or open
      const parts: unknown[] = []
      if (s.running) parts.push(<Text><Text color={C.clay}>{spin} </Text>{s.running} running</Text>)
      if (s.done) parts.push(<Text><Text color={C.ok}>✓ </Text>{s.done} done</Text>)
      if (s.needs) parts.push(<Text color={C.warn} bold>! {s.needs} needs you</Text>)
      const joined = parts.flatMap((p, i) => (i ? [<Text dimColor>{'  ·  '}</Text>, p] : [p]))
      // Nothing to count: /stand hangs on the last row instead of standing alone
      const hang = parts.length ? null : g ? 'block' : !isOpen && ctxHigh ? 'ctx' : null
      return (
        <Box flexDirection="column">
          {list}
          {!isOpen && ctxHigh && ctxRow(hang === 'ctx')}
          {blockLine(hang === 'block')}
          {parts.length > 0 && (
            <Box>
              {joined as never}
              <Hint />
            </Box>
          )}
          {!parts.length && !hang && <Text dimColor>/stand</Text>}
        </Box>
      )
    }

    // quiet: the open list already shows every row, so no footer repeats it
    const parts: unknown[] = []
    if (!isOpen && s.running) parts.push(<Text><Text color={C.clay}>{spin} </Text>{s.running} running</Text>)
    // Without a footer, /stand hangs on the last row
    const last = isOpen || parts.length ? null : g ? 'block' : ctxHigh ? 'ctx' : 'disk'
    return (
      <Box flexDirection="column">
        {list}
        {diskNeeds && !isOpen && diskRow(last === 'disk')}
        {ctxHigh && !isOpen && ctxRow(last === 'ctx')}
        {blockLine(last === 'block')}
        {parts.length > 0 && (
          <Box>
            {parts as never}
            <Hint />
          </Box>
        )}
      </Box>
    )
  })