high-command

  on('ui.render', { component: 'Pane', requestId: 'high-command' }, async ($, e) => {
    const ui = $.ui.resolve(e)
    try {
      const chosen = await read($, selectedLane)
      const laneId = chosen === '' ? undefined : chosen ?? e.props.view.agentId
      const { list, rows } = await readRoster($, laneId)
      const thread = threadOf(list, rows, laneId === undefined ? await read($, openThread) : (await readLane($, laneId)).openThread)
      const now = await $.clock.now()
      return paneTree(ui, { rows, now, thread, laneId, rosterPage: laneId === undefined ? await read($, rosterPage) : (await readLane($, laneId)).rosterPage, lanePage: await read($, lanePage),
        laneIds: Object.keys(await read($, lanes)), agents: Object.values(await read($, agents)),
        capture: await read($, capture), evicted: list.at(-1)?.evictedTotal ?? 0,
      }, paneActions($, laneId))
    } catch (error) {
      const { Text } = ui
      return <Text color="red">{`high-command: ui.render (Pane): ${causeOf(error)}`}</Text>
    }
  })

export function paneTree(ui: HighCommandElements, model: PaneModel, actions: PaneActions): RenderElement {
  const { Box, Text, Button } = ui
  const labels = peerLabels(model.rows.map(row => row.peer))
  const agentMap = new Map((model.agents ?? []).map(agent => [agent.id, agent]))
  const ids = [...new Set([...(model.laneIds ?? []), ...agentMap.keys()])].sort()
  const pages = Math.max(1, Math.ceil(ids.length / 10))
  const page = Math.max(0, Math.min(model.lanePage ?? 0, pages - 1))
  return <Box flexDirection="column">
    {model.capture && <Text dimColor>{captureLabel(model.capture, model.now)}</Text>}
    <Text dimColor>Order: observation time. Counts cover retained messages.</Text>
    {(model.evicted ?? 0) > 0 && <Text>{`History trimmed: ${count(model.evicted!, 'message')} permanently evicted.`}</Text>}
    {ids.length > 0 && <Box flexDirection="column">
      <Text bold>{model.laneId === undefined ? 'Main inbox' : `Agent observations: ${peerLabel(model.laneId)}`}</Text>
      <Text dimColor>Send and receive observations are separate. Split-pane traffic is unavailable; roster snapshots do not confirm liveness.</Text>
      <Button key="lane:main" label="Main inbox" onPress={() => actions.lane('')} />
      {ids.slice(page * 10, page * 10 + 10).map((id, index) => {
        const agent = agentMap.get(id)
        // The status goes on its own line under the button: beside a long button, a narrow dock left it a few columns.
        return <Box flexDirection="column">
          <Button key={`lane:${page * 10 + index}`} label={`${peerLabel(agent?.name ?? id)} (${peerLabel(id)})`} onPress={() => actions.lane(id)} />
          {agent && <Box paddingLeft={2}>
            <Text>{`${agent.status}; ${agent.source} at ${clockLabel(agent.at, model.now)}${agent.lastEvent ? `; lifecycle observation: ${agent.lastEvent.word} at ${clockLabel(agent.lastEvent.at, model.now)}` : ''}`}</Text>
          </Box>}
        </Box>
      })}
      {page > 0 && <Button key="lanes:previous" label="Previous agents" onPress={() => actions.lanePage(page - 1)} />}
      {page + 1 < pages && <Button key="lanes:next" label="More agents" onPress={() => actions.lanePage(page + 1)} />}
    </Box>}
    {model.thread === undefined ? rosterView(ui, model, actions, labels) : threadView(ui, model.now, model.thread, actions, labels.get(model.thread.row.peer)!)}
  </Box>
}

function rosterView({ Box, Text, Button }: HighCommandElements, model: PaneModel, actions: PaneActions, labels: Map<string, string>): RenderElement {
  const unread = unreadTotal(model.rows)
  const pages = Math.max(1, Math.ceil(model.rows.length / LIMITS.rosterRows))
  const page = Math.max(0, Math.min(model.rosterPage ?? 0, pages - 1))
  return (
    <Box flexDirection="column">
      <Box flexDirection="row" columnGap={1}>
        <Text bold>High Command</Text>
        <Text dimColor>{`· ${unread} unread (retained) · ${count(model.rows.length, 'peer')}`}</Text>
        {unread > 0 && <Button key="pane:read-all" label="Read all" hotkey="r" onPress={actions.readAll} />}
      </Box>
      {model.rows.length === 0 && <Text dimColor>No messages from teammates or other sessions in this capture window.</Text>}
      {model.rows.slice(page * LIMITS.rosterRows, (page + 1) * LIMITS.rosterRows).map((row, index) => (
        <Box flexDirection="row" columnGap={1}>
          <Button
            key={`open:${row.last.seq}`}
            label={labels.get(row.peer)!}
            plain
            {...(index < LIMITS.hotkeys ? { hotkey: String(index + 1) } : {})}
            onPress={() => actions.openThread(row.peer)}
          />
          <Text bold={row.unread > 0} wrap="truncate-end">
            {rowText(row, model.now)}
          </Text>
        </Box>
      ))}
      {pages > 1 && <Text dimColor>{`Peer page ${page + 1} of ${pages}`}</Text>}
      {page > 0 && <Button key="roster:previous" label="Previous peers" onPress={() => actions.rosterPage(page - 1)} />}
      {page + 1 < pages && <Button key="roster:next" label="More peers" onPress={() => actions.rosterPage(page + 1)} />}
    </Box>
  )
}

function threadView({ Box, Text, Button }: HighCommandElements, now: number, thread: Thread, actions: PaneActions, label: string): RenderElement {
  const { row, since, shown, hidden, fresh } = thread
  const details = joined([
    stateLabel(row.state, now),
    trustLabel(row.trust),
    count(shown.length + hidden, 'retained message'),
    fresh > 0 ? `${fresh} new` : undefined,
  ])
  return (
    <Box flexDirection="column">
      <Box flexDirection="row" columnGap={1}>
        <Button key="pane:back" label="Back" hotkey="b" onPress={actions.back} />
        <Text bold>{label}</Text>
        <Button key="pane:identity" label="Identity" onPress={() => actions.identity(thread.identityPage === undefined ? 0 : undefined)} />
        <Text dimColor>{`· ${details}`}</Text>
        {row.unread > 0 && <Button key="pane:mark-read" label="Mark read" hotkey="r" onPress={() => actions.markRead(row.peer)} />}
      </Box>
      {thread.identityPage !== undefined && <Box flexDirection="column">
        <Text>{`Identity part ${thread.identityPage + 1} of ${Math.ceil(row.peer.length / 1000)} (${row.peer.length} characters):`}</Text>
        <Text>{identityPart(row.peer, thread.identityPage)}</Text>
        {thread.identityPage > 0 && <Button key="identity:previous" label="Previous identity part" onPress={() => actions.identity(thread.identityPage! - 1)} />}
        {(thread.identityPage + 1) * 1000 < row.peer.length && <Button key="identity:next" label="Next identity part" onPress={() => actions.identity(thread.identityPage! + 1)} />}
      </Box>}
      {shown.some(entry => entry.direction === 'out') && (
        <Text dimColor>Send attempts show observed text. Reported success is not a receipt for that text. Core evidence covers only the latest traced call, never reading or every send.</Text>
      )}
      {shown.map(entry => {
        const isFresh = isNewer(entry, since)
        return (
          <Box flexDirection="column" marginTop={1}>
            <Text bold={isFresh}>{entryHeader(entry, isFresh, now)}</Text>
            <Text wrap="wrap">{entry.body}</Text>
            {(entry.refusal !== undefined || entry.core !== undefined) && <Button key={`reason:${entry.seq}`} label="Send details" onPress={() => actions.reason(entry.seq)} />}
            {thread.reasonSeq === entry.seq && entry.refusal !== undefined && <Box flexDirection="column">
              <Text>{entry.refusal.body}</Text>
              {entry.refusal.fullChars > entry.refusal.body.length && <Text dimColor>{`Refusal truncated: ${entry.refusal.fullChars} characters originally; ${entry.refusal.body.length} retained.`}</Text>}
            </Box>}
            {thread.reasonSeq === entry.seq && entry.core !== undefined && <Box flexDirection="column">
              <Text>{`Latest traced core recipient (bounded): ${entry.core.to}`}</Text>
              <Text>{`Core queue outcome: ${entry.core.isDelivered ? 'accepted, not read' : `refused: ${entry.core.reason}`}`}</Text>
              <Text>{entry.core.body}</Text>
              {entry.core.fullChars > entry.core.body.length && <Text>{`Core text truncated: ${entry.core.fullChars} characters originally.`}</Text>}
            </Box>}
            {entry.fullChars > entry.body.length && (
              <Text dimColor>{`(${count(entry.fullChars - entry.body.length, 'more character')} in the transcript.)`}</Text>
            )}
          </Box>
        )
      })}
      {thread.page > 0 && <Button key="pane:newer" label="Newer" onPress={() => actions.page(thread.page - 1)} />}
      {thread.page + 1 < thread.pages && <Button key="pane:older" label="Older" onPress={() => actions.page(thread.page + 1)} />}
      {hidden > 0 && (
        <Box marginTop={1}>
          <Text dimColor>{`Page ${thread.page + 1} of ${thread.pages}; ${count(hidden, 'retained message')} on other pages.`}</Text>
        </Box>
      )}
    </Box>
  )
}

  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
    if (e.props.hasSurvey) return next(e)
    const below = await next(e)
    const list = await read($, entries)
    // A Hide holds while the person had seen every inbound entry: those in the window and those recorded before.
    if ((await read($, hiddenThrough)) >= Math.max(await read($, inboundThrough), newestInboundSeq(list))) return below
    const rows = rosterOf(list, {}, await read($, readThrough))
    const waiting = rows.filter(row => row.unread > 0)
    if (waiting.length === 0) return below
    // Other mods draw `below`; when the band would push it past the engine's bounds, it yields.
    const band = bandTree($.ui.resolve(e), waiting, bandActions($), below, peerLabels(rows.map(row => row.peer)))
    if (fitsBounds(band)) return band
    const compact = compactBandTree($.ui.resolve(e), waiting, bandActions($), below)
    return fitsBounds(compact) ? compact : below
  })

export function bandTree(
  { Box, Text, Button }: HighCommandElements,
  waiting: readonly RosterRow[],
  actions: BandActions,
  below: RenderElement,
  labels: Map<string, string>,
): RenderElement {
  const named = waiting.slice(0, LIMITS.bandPeers).map(row => `${labels.get(row.peer)} ${row.unread}`)
  const more = waiting.length > LIMITS.bandPeers ? [`+${waiting.length - LIMITS.bandPeers} more`] : []
  return (
    <Box flexDirection="column">
      <Box flexDirection="row" columnGap={1}>
        <Text wrap="truncate-end">{`High Command · ${unreadTotal(waiting)} unread (retained) — ${[...named, ...more].join(' · ')}`}</Text>
        <Button key="band:open" label="Open" hotkey="o" onPress={actions.open} />
        <Button key="band:read-all" label="Read all" hotkey="r" onPress={actions.readAll} />
        <Button key="band:hide" label="Hide" hotkey="h" onPress={actions.hide} />
      </Box>
      {below}
    </Box>
  )
}