@orkastery/cli 0.5.3 → 0.5.6

package/adapters/claude-code/mods/ork-torre/hooks/painel.tsx

@@ -0,0 +1,344 @@
+// O painel da Torre de Controle (RM-059, fatia F1; ficha M3 do plano dos mods). Uma linha por thread aberta
+// desta maquina, montada so do retrato da thread (`ork.maestro-snapshot/v1`) que a ponte entrega por
+// `$.ork.retrato`: o trilho das seis fases, o modo, quem conduz e desde quando, o bloqueio tipado numa frase,
+// os pedidos ao dono e as acoes que o nucleo declara disponiveis. Modulo puro: o `$` fica no register.tsx, e
+// o desenho recebe a tabela de elementos que a superficie resolveu.
+import type {
+  TorreAcao, TorreEstado, TorreFase, TorreLinha, TorreLinhaDaRede, TorreMostrado, TorrePedido, TorreQuadro, TorreRede, TorreSessao,
+} from '../types'
+import { fraseDoMotivo, MOTIVOS_DO_DONO } from './frases'
+
+export const FASES: readonly TorreFase[] = ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER']
+/** A ordem das linhas (D6): o que pede acao do dono primeiro. */
+export const ORDEM_DO_ESTADO: readonly TorreEstado[] = ['espera-voce', 'parada', 'andando', 'quieta', 'sem-leitura']
+/** Teto de threads no painel: cada uma custa um retrato. */
+export const TETO_DE_THREADS = 40
+/** As operacoes que so leem; as outras tem efeito e nunca rodam pela Torre (D4). */
+export const LEITURAS: readonly string[] = ['thread.status', 'thread.observe', 'git.status']
+/** A ordem e o rotulo de cada operacao do retrato (o enum `operation` do nucleo). */
+export const ROTULO_DA_ACAO: Readonly<Record<string, string>> = {
+  'thread.status': 'Estado',
+  'thread.observe': 'Observar',
+  'git.status': 'Git',
+  'hitl.decide': 'Decidir',
+  'retry': 'Retomar',
+  'phase': 'Fase seguinte',
+  'verify': 'Verificar',
+  'ship': 'Entregar',
+  'master': 'Nota do MASTER',
+  'git.commit': 'Commit',
+  'creation': 'Criação',
+}
+const ORDEM_DAS_ACOES = Object.keys(ROTULO_DA_ACAO)
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+const SECOES_LIDAS = ['threads', 'sessions', 'blockers', 'hitl', 'nextActions']
+const TAG_DO_MODO: Readonly<Record<string, string>> = { classic: '#Classic', maestro: '#Maestro', auto: '#Auto', fast: '#Fast' }
+const MARCA_DO_ESTADO: Readonly<Record<TorreEstado, string>> = {
+  'espera-voce': '!', 'parada': 'x', 'andando': '>', 'quieta': '-', 'sem-leitura': '?',
+}
+/** Os valores do nucleo que chegam ao dono, em portugues; o que a tabela nao conhece aparece cru. */
+const EM_PORTUGUES: Readonly<Record<string, string>> = {
+  delivered: 'entregue', incomplete: 'incompleta', pending: 'pendente', recorded: 'gravado',
+  'ratificacao-pendente': 'ratificação pendente', unknown: 'desconhecido', working: 'trabalhando', running: 'rodando',
+  blocked: 'bloqueada', completed: 'concluída', done: 'concluída', stopped: 'parada', exited: 'encerrada',
+  conflict: 'em conflito', unavailable: 'indisponível', stale: 'velha', available: 'disponível',
+}
+
+export function emPortugues(valor: string): string {
+  return Object.prototype.hasOwnProperty.call(EM_PORTUGUES, valor) ? EM_PORTUGUES[valor] as string : valor
+}
+
+type Item = { id?: unknown; title?: unknown; status?: unknown; refs?: unknown; facts?: unknown; action?: unknown }
+type Retrato = { sections?: Record<string, { state?: unknown; items?: unknown } | undefined> } | null | undefined
+
+function texto(v: unknown): string | null {
+  return typeof v === 'string' && v.trim() !== '' ? v.trim() : null
+}
+
+function itens(retrato: Retrato, secao: string): Item[] {
+  const s = retrato?.sections?.[secao]
+  return Array.isArray(s?.items) ? (s?.items as unknown[]).filter((i): i is Item => !!i && typeof i === 'object') : []
+}
+
+function fatos(item: Item): Record<string, unknown> {
+  return item.facts && typeof item.facts === 'object' ? item.facts as Record<string, unknown> : {}
+}
+
+/** O item e desta thread pela referencia `thread`, nunca pelo titulo. */
+function daThread(item: Item, thread: string): boolean {
+  return Array.isArray(item.refs) && item.refs.some(r => !!r && typeof r === 'object' &&
+    (r as { kind?: unknown }).kind === 'thread' && (r as { id?: unknown }).id === thread)
+}
+
+/** As threads abertas da consulta `thread.list` da ponte (`ork thread list --json`), em ordem e com teto. */
+export function abertasDaLista(lista: unknown, teto = TETO_DE_THREADS): { ids: string[]; omitidas: number } {
+  const threads = (lista as { threads?: unknown } | null)?.threads
+  if (!Array.isArray(threads)) throw new Error('a lista das threads veio sem o campo threads')
+  const ids = [...new Set(threads.filter(t => !!t && typeof t === 'object' && typeof t.id === 'string' &&
+    ID_DE_THREAD.test(t.id) && t.status !== 'fechada').map(t => t.id as string))].sort()
+  return { ids: ids.slice(0, teto), omitidas: Math.max(0, ids.length - teto) }
+}
+
+/** O estado da linha (D6): pedido ou bloqueio do dono, outro bloqueio, alguem conduzindo, ou nada. */
+export function estadoDaLinha(l: Pick<TorreLinha, 'pedidos' | 'bloqueio' | 'conducao'>, lido: boolean): TorreEstado {
+  if (!lido) return 'sem-leitura'
+  if (l.pedidos.length > 0 || (l.bloqueio !== null && MOTIVOS_DO_DONO.includes(l.bloqueio.motivo))) return 'espera-voce'
+  if (l.bloqueio !== null) return 'parada'
+  return l.conducao !== null ? 'andando' : 'quieta'
+}
+
+/**
+ * A linha de uma thread a partir do retrato dela. Sem retrato (a leitura falhou), a linha diz que nao leu e
+ * por que, sem inventar fase nem estado.
+ */
+export function linhaDaThread(thread: string, retrato: unknown,
+  meta: { fonte: TorreLinha['fonte']; lidoEm: number | null; erro?: string }): TorreLinha {
+  const r = retrato as Retrato
+  const lido = !!r && typeof r === 'object' && !meta.erro
+  const linha = itens(r, 'threads').find(i => i.id === thread)
+  const f = linha ? fatos(linha) : {}
+  const sessoesDoRetrato = itens(r, 'sessions').filter(i => daThread(i, thread))
+  const conducao = sessoesDoRetrato.map(i => texto(fatos(i).conduction)).find((c): c is string => c !== null) ?? null
+  const sessoes: TorreSessao[] = sessoesDoRetrato.filter(i => typeof i.id === 'string' && !i.id.startsWith('conducao:'))
+    .map(i => ({ id: i.id as string, rotulo: texto(i.title) ?? '', estado: texto(i.status) ?? 'unknown',
+      conduz: texto(fatos(i).conduction) !== null, confirmada: fatos(i).nativeConfirmed === true }))
+  const gate = itens(r, 'blockers').find(i => daThread(i, thread) && i.id === `gate:${thread}`)
+  const motivo = gate ? texto(fatos(gate).reason) ?? texto(gate.title) : null
+  const pedidos: TorrePedido[] = itens(r, 'hitl').filter(i => daThread(i, thread) && i.status !== 'stale' && typeof i.id === 'string')
+    .map(i => ({ id: i.id as string, texto: texto(i.title) ?? '', prazo: texto(fatos(i).deadlineLocal) ?? '',
+      recomendacao: texto(fatos(i).recommendation) ?? '' }))
+  const acoes: TorreAcao[] = itens(r, 'nextActions').filter(i => daThread(i, thread))
+    .map(i => i.action as { operation?: unknown; available?: unknown } | undefined)
+    .filter((a): a is { operation: string; available: true } => !!a && a.available === true && typeof a.operation === 'string')
+    .map(a => ({ operacao: a.operation }))
+    .filter((a, i, todas) => todas.findIndex(b => b.operacao === a.operacao) === i)
+    .sort((a, b) => posicao(a.operacao) - posicao(b.operacao))
+  const lacunas = lido
+    ? [...(linha ? [] : ['a thread não veio no retrato']),
+      ...SECOES_LIDAS.filter(s => ['unavailable', 'conflict', 'stale'].includes(String(r?.sections?.[s]?.state)))
+        .map(s => `${s}: ${emPortugues(String(r?.sections?.[s]?.state))}`)]
+    : [meta.erro ?? 'o retrato não veio']
+  const base = {
+    thread,
+    fase: texto(f.phase),
+    modo: texto(f.mode),
+    conducao,
+    bloqueio: motivo ? { motivo, frase: fraseDoMotivo(motivo) } : null,
+    pedidos,
+    sessoes,
+    entrega: texto(itens(r, 'ship').find(i => daThread(i, thread))?.status),
+    master: texto(itens(r, 'master').find(i => daThread(i, thread))?.status),
+    acoes,
+    fonte: meta.fonte,
+    lidoEm: meta.lidoEm,
+    lacunas,
+  }
+  return { ...base, estado: estadoDaLinha(base, lido) }
+}
+
+function posicao(operacao: string): number {
+  const i = ORDEM_DAS_ACOES.indexOf(operacao)
+  return i < 0 ? ORDEM_DAS_ACOES.length : i
+}
+
+/** A acao com efeito que o estado da thread pede (D15); commit e criacao nunca sao acao do dono. */
+function pedidaPeloEstado(operacao: string, l: TorreLinha): boolean {
+  const motivo = l.bloqueio?.motivo ?? ''
+  switch (operacao) {
+    case 'hitl.decide': return l.pedidos.length > 0 || motivo === 'human.pending'
+    case 'retry': return l.estado === 'parada'
+    case 'phase': return l.estado === 'quieta' && l.fase !== 'MASTER'
+    case 'verify': return /^(claims|verify)\./.test(motivo)
+    case 'ship': return l.fase === 'SHIP' && l.entrega !== 'delivered' && l.estado !== 'andando'
+    case 'master': return (l.entrega === 'delivered' || l.fase === 'MASTER') && l.master !== 'recorded'
+    default: return false
+  }
+}
+
+/**
+ * As acoes que a Torre oferece ao dono (D15). O `available` do retrato so diz que a ferramenta existe no
+ * servidor (core/src/maestro-actions.ts): a leitura aparece sempre que disponivel, e a acao com efeito so
+ * quando, alem de disponivel, o estado da thread a pede.
+ */
+export function acoesRelevantes(l: TorreLinha): TorreAcao[] {
+  if (l.estado === 'sem-leitura') return []
+  return l.acoes.filter(a => LEITURAS.includes(a.operacao) || pedidaPeloEstado(a.operacao, l))
+}
+
+/** As linhas na ordem do estado (D6) e, dentro dele, pelo id. */
+export function ordenarLinhas(linhas: readonly TorreLinha[]): TorreLinha[] {
+  return [...linhas].sort((a, b) => ORDEM_DO_ESTADO.indexOf(a.estado) - ORDEM_DO_ESTADO.indexOf(b.estado) ||
+    (a.thread < b.thread ? -1 : a.thread > b.thread ? 1 : 0))
+}
+
+/** O trilho das seis fases: feita, atual, por vir; fase fora do ciclo deixa o trilho apagado. */
+export function trilho(fase: string | null): string {
+  const i = fase === null ? -1 : FASES.indexOf(fase as TorreFase)
+  return FASES.map((_, j) => (i < 0 ? '·' : j < i ? '●' : j === i ? '◉' : '○')).join('')
+}
+
+export function modoComTag(modo: string | null): string {
+  if (modo === null) return ''
+  return TAG_DO_MODO[modo] ?? `#${modo}`
+}
+
+/** Idade curta: segundos, minutos ou horas. */
+export function idade(ms: number): string {
+  const t = Math.max(0, ms)
+  if (t < 60000) return `${Math.floor(t / 1000)} s`
+  if (t < 3600000) return `${Math.floor(t / 60000)} min`
+  return `${Math.floor(t / 3600000)} h`
+}
+
+/** O placar de uma linha no topo do painel. */
+export function placar(q: TorreQuadro, agora: number): string {
+  if (q.lidoEm === null) return q.erro ? `Torre: não li o núcleo (${q.erro})` : 'Torre: lendo o núcleo…'
+  const lido = `lido há ${idade(agora - q.lidoEm)}`
+  const total = q.linhas.length + q.omitidas
+  if (total === 0) return `nenhuma thread aberta nesta máquina · ${lido}`
+  const conta = (e: TorreEstado) => q.linhas.filter(l => l.estado === e).length
+  const partes = [total === 1 ? '1 thread aberta' : `${total} threads abertas`]
+  const espera = conta('espera-voce')
+  const paradas = conta('parada')
+  const andando = conta('andando')
+  const semLeitura = conta('sem-leitura')
+  if (espera) partes.push(espera === 1 ? '1 espera você' : `${espera} esperam você`)
+  if (paradas) partes.push(paradas === 1 ? '1 parada' : `${paradas} paradas`)
+  if (andando) partes.push(`${andando} andando`)
+  if (semLeitura) partes.push(semLeitura === 1 ? '1 sem leitura' : `${semLeitura} sem leitura`)
+  partes.push(lido)
+  if (q.erro) partes.push(`a lista não foi relida: ${q.erro}`)
+  return partes.join(' · ')
+}
+
+/** A primeira linha de cada thread: estado, id, trilho, fase e modo. */
+export function cabecalhoDaLinha(l: TorreLinha): string {
+  return [MARCA_DO_ESTADO[l.estado], l.thread, `${trilho(l.fase)} ${l.fase ?? '?'}`, modoComTag(l.modo)]
+    .filter(p => p !== '').join('  ')
+}
+
+/** Uma linha de texto com o que ela mostra ao dono, quando e algo que o Telegram tambem avisaria (D10). */
+export type ItemDoPainel = { texto: string; mostrado?: TorreMostrado }
+
+/** As linhas de baixo: o que espera o dono, o bloqueio, quem conduz, as acoes pedidas e as lacunas. */
+export function detalhesDaLinha(l: TorreLinha): ItemDoPainel[] {
+  const saida: ItemDoPainel[] = []
+  for (const p of l.pedidos) {
+    const texto = `espera você: ${p.texto || p.id}`
+    saida.push({ texto: `${texto}${p.prazo ? ` (prazo ${p.prazo})` : ''}`, mostrado: { chave: `hitl:${p.id}`, thread: l.thread, texto: `${l.thread}: ${texto}` } })
+  }
+  if (l.bloqueio) {
+    const doDono = MOTIVOS_DO_DONO.includes(l.bloqueio.motivo)
+    saida.push({ texto: `${doDono ? 'espera você' : 'parada'}: ${l.bloqueio.frase} (${l.bloqueio.motivo})`,
+      mostrado: { chave: `bloqueio:${l.thread}:${l.bloqueio.motivo}`, thread: l.thread, texto: `${l.thread}: ${l.bloqueio.frase}` } })
+  }
+  if (l.estado !== 'sem-leitura') saida.push({ texto: l.conducao ?? 'ninguém conduz agora' })
+  const efeitos = acoesRelevantes(l).filter(a => !LEITURAS.includes(a.operacao)).map(a => ROTULO_DA_ACAO[a.operacao] ?? a.operacao)
+  if (efeitos.length) saida.push({ texto: `ações: ${efeitos.join(' · ')}` })
+  if (l.lacunas.length) saida.push({ texto: `lacuna: ${l.lacunas.join('; ')}` })
+  return saida
+}
+
+/** Tudo que o quadro mostraria e o Telegram tambem avisa: cada bloqueio e cada pedido, com a chave. */
+export function mostradosDoQuadro(q: TorreQuadro): TorreMostrado[] {
+  return q.linhas.flatMap(l => detalhesDaLinha(l).flatMap(d => (d.mostrado ? [d.mostrado] : [])))
+}
+
+/** A linha da rede no painel (D11): nao lida, lida com a idade e as lacunas, ou o erro da ultima tentativa. */
+export function placarDaRede(rede: TorreRede | null | undefined, agora: number): string {
+  if (!rede || rede.lidoEm === null) return rede?.erro ? `rede: não lida (${rede.erro})` : 'rede: não lida'
+  const n = rede.linhas.length
+  const maquinas = rede.maquinas === 1 ? '1 outra máquina' : `${rede.maquinas} outras máquinas`
+  const partes = [`rede: ${n === 0 ? 'nenhuma thread ativa' : n === 1 ? '1 thread' : `${n} threads`} em ${maquinas}, lida há ${idade(agora - rede.lidoEm)}`]
+  if (rede.lacunas) partes.push(rede.lacunas === 1 ? '1 lacuna' : `${rede.lacunas} lacunas`)
+  if (rede.erro) partes.push(`a última leitura falhou: ${rede.erro}`)
+  return partes.join(' · ')
+}
+
+/** As linhas da rede que nao sao threads abertas aqui: a local vence. */
+export function linhasDaRedeVisiveis(rede: TorreRede | null | undefined, q: TorreQuadro): TorreLinhaDaRede[] {
+  const locais = new Set(q.linhas.map(l => l.thread))
+  return (rede?.linhas ?? []).filter(l => !locais.has(l.thread))
+}
+
+/** A linha de uma thread de outra maquina: a marca, o id, o trilho, a fase, o modo, a maquina e a batida. */
+export function cabecalhoDaRede(l: TorreLinhaDaRede): string {
+  const batida = l.semBatida ? 'sem batida' : l.idadeMin === null ? 'batida ilegível' : `batida há ${l.idadeMin} min`
+  return [l.esperaVoce ? '!' : '~', l.thread, `${trilho(l.fase)} ${l.fase}`, l.modo, `@${l.maquina}, ${batida}`].filter(p => p !== '').join('  ')
+}
+
+/** Corta o texto a largura, quando ha uma, para a linha ocupar uma linha so da tela. */
+export function cortar(texto: string, largura?: number): string {
+  if (largura === undefined || largura < 2 || texto.length <= largura) return texto
+  return `${texto.slice(0, largura - 1)}…`
+}
+
+/** Uma linha da tela do painel, na ordem do desenho; cada uma ocupa uma linha so. */
+export type LinhaDoPainel =
+  | { tipo: 'placar' | 'rede' | 'omitidas'; texto: string; thread?: undefined; mostrado?: undefined }
+  | { tipo: 'cabecalho' | 'rede-cabecalho' | 'rede-pergunta'; texto: string; thread: string; mostrado?: undefined }
+  | { tipo: 'detalhe'; texto: string; thread: string; indice: number; mostrado?: TorreMostrado }
+
+/**
+ * As linhas da tela do painel, na ordem em que o desenho as poe: o placar, a linha da rede, cada thread desta
+ * maquina (a primeira linha e as de baixo), o que ficou alem do teto e as threads das outras maquinas. A
+ * janela de rolagem conta estas linhas, uma a uma.
+ */
+export function linhasDoPainel(q: TorreQuadro, opcoes: { agora: number; rede?: TorreRede | null }): LinhaDoPainel[] {
+  const saida: LinhaDoPainel[] = [{ tipo: 'placar', texto: placar(q, opcoes.agora) }, { tipo: 'rede', texto: placarDaRede(opcoes.rede, opcoes.agora) }]
+  for (const l of q.linhas) {
+    saida.push({ tipo: 'cabecalho', texto: cabecalhoDaLinha(l), thread: l.thread })
+    detalhesDaLinha(l).forEach((d, indice) => saida.push({ tipo: 'detalhe', texto: `  ${d.texto}`, thread: l.thread, indice,
+      ...(d.mostrado ? { mostrado: d.mostrado } : {}) }))
+  }
+  if (q.omitidas > 0) saida.push({ tipo: 'omitidas', texto: `+${q.omitidas} threads abertas além do teto de ${TETO_DE_THREADS}` })
+  for (const l of linhasDaRedeVisiveis(opcoes.rede, q)) {
+    saida.push({ tipo: 'rede-cabecalho', texto: cabecalhoDaRede(l), thread: l.thread })
+    if (l.esperaVoce) saida.push({ tipo: 'rede-pergunta', texto: `  espera você: ${l.pergunta ?? 'pausa humana valendo'}`, thread: l.thread })
+  }
+  return saida
+}
+
+/**
+ * O que esta dentro da janela de rolagem (D10): as linhas `primeira` em diante da tela, de `offset` ate
+ * `offset + bodyRows`. Sem janela, nada conta como visto: o registro nunca diz que o dono viu o que talvez
+ * nao estivesse na tela.
+ */
+export function mostradosVisiveis(linhas: ReadonlyArray<{ texto: string; mostrado?: TorreMostrado | undefined }>, primeira: number,
+  janela: { offset: number; bodyRows: number } | undefined): TorreMostrado[] {
+  if (!janela || !(janela.bodyRows > 0)) return []
+  const fim = janela.offset + janela.bodyRows
+  return linhas.flatMap((l, i) => (l.mostrado && primeira + i >= janela.offset && primeira + i < fim ? [l.mostrado] : []))
+}
+
+/**
+ * A arvore do painel com os elementos que a superficie resolveu (`$.ui.resolve(e)` no register.tsx), uma
+ * linha da tela por elemento. A primeira linha de cada thread desta maquina e um botao que abre o detalhe dela
+ * (T1.2); as threads das outras maquinas vem depois, sem botao (T1.3).
+ */
+export function desenharPainel(el: { Box: any; Text: any; Button: any }, q: TorreQuadro,
+  opcoes: { agora: number; largura?: number; abrir?: (thread: string) => void; rede?: TorreRede | null; lerRede?: () => void }) {
+  const { Box, Text, Button } = el
+  return (
+    <Box flexDirection="column">
+      {linhasDoPainel(q, opcoes).map(l => {
+        if (l.tipo === 'placar') return <Text key="placar" bold wrap="truncate">{l.texto}</Text>
+        if (l.tipo === 'rede') {
+          return (
+            <Box key="rede" flexDirection="row">
+              <Text key="placar-da-rede" dimColor wrap="truncate">{l.texto}</Text>
+              <Button key="ler-rede" label="Ler a rede" onPress={() => opcoes.lerRede?.()} />
+            </Box>
+          )
+        }
+        if (l.tipo === 'cabecalho') {
+          return <Button key={`abrir:${l.thread}`} plain onPress={() => opcoes.abrir?.(l.thread)}>{cortar(l.texto, opcoes.largura)}</Button>
+        }
+        if (l.tipo === 'detalhe') return <Text key={`detalhe:${l.thread}:${l.indice}`} dimColor wrap="truncate">{l.texto}</Text>
+        if (l.tipo === 'omitidas') return <Text key="omitidas" dimColor wrap="truncate">{l.texto}</Text>
+        if (l.tipo === 'rede-cabecalho') return <Text key={`rede-cabecalho:${l.thread}`} wrap="truncate">{l.texto}</Text>
+        return <Text key={`rede-pergunta:${l.thread ?? ''}`} dimColor wrap="truncate">{l.texto}</Text>
+      })}
+    </Box>
+  )
+}

package/adapters/claude-code/mods/ork-torre/hooks/rede.ts

@@ -0,0 +1,97 @@
+// A rede e a linha da faixa na Torre de Controle (RM-059, fatia F1, T1.3; D9 e D11 da thread). O retrato do
+// nucleo nao le outras maquinas (`notConsulted` do `ork_maestro`): as threads delas vem do panorama da rede
+// (`ork_network_roadmap`, contrato `ork.network-roadmap/v1`), lido so quando o dono pede ou, com o painel a
+// vista, no maximo a cada 10 min. Lacuna nunca vira "vazio", e thread que esta aberta aqui nao se repete. A
+// linha da faixa resume o quadro numa linha so, e a ponte a desenha. Modulo puro.
+import type { TorreLinhaDaRede, TorreQuadro, TorreRede } from '../types'
+
+export const CONTRATO_DA_REDE = 'ork.network-roadmap/v1'
+/** Com o painel a vista, a rede e relida no maximo neste intervalo; o botao le na hora. */
+export const PERIODO_DA_REDE_MS = 600000
+export const TETO_DE_LINHAS_DA_REDE = 30
+/** O mesmo teto que a ponte aplica ao texto de cada linha da faixa. */
+export const TETO_DO_TEXTO_DA_FAIXA = 200
+
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+
+function lista(v: unknown): Array<Record<string, unknown>> {
+  return Array.isArray(v) ? v.filter((x): x is Record<string, unknown> => !!x && typeof x === 'object') : []
+}
+
+/**
+ * As threads ativas das outras maquinas, lidas do panorama da rede que o `ork_network_roadmap` devolve
+ * (`{ texto, panorama }`). Entra so maquina que nao e esta e cujas threads foram lidas; thread aberta aqui
+ * (`locais`) ou repetida em outra maquina entra uma vez so. As lacunas do panorama sao contadas, nunca
+ * escondidas.
+ */
+export function redeDoPanorama(resposta: unknown, locais: readonly string[], agora: number): TorreRede {
+  const panorama = (resposta as { panorama?: unknown } | null)?.panorama as Record<string, unknown> | null | undefined
+  if (!panorama || panorama.contrato !== CONTRATO_DA_REDE || !Array.isArray(panorama.projetos)) {
+    throw new Error('o panorama da rede veio fora do contrato')
+  }
+  const vistas = new Set(locais)
+  const linhas: TorreLinhaDaRede[] = []
+  let maquinas = 0
+  let lacunas = lista(panorama.lacunas).length
+  for (const projeto of lista(panorama.projetos)) {
+    lacunas += lista(projeto.lacunas).length
+    for (const m of lista(projeto.maquinas)) {
+      if (m.estaMaquina === true || m.threadsLidas !== true) continue
+      maquinas++
+      for (const t of lista(m.ativas)) {
+        if (typeof t.id !== 'string' || !ID_DE_THREAD.test(t.id) || vistas.has(t.id) || t.status === 'fechada') continue
+        vistas.add(t.id)
+        linhas.push({
+          thread: t.id,
+          maquina: typeof m.maquina === 'string' ? m.maquina : '?',
+          fase: typeof t.fase === 'string' ? t.fase : '?',
+          modo: typeof t.modo === 'string' ? t.modo : '',
+          esperaVoce: t.esperaVoce === true,
+          pergunta: typeof t.pergunta === 'string' && t.pergunta.trim() !== '' ? t.pergunta.trim() : null,
+          idadeMin: typeof m.idadeMin === 'number' && Number.isFinite(m.idadeMin) ? Math.max(0, Math.round(m.idadeMin)) : null,
+          semBatida: m.semBatida === true,
+        })
+      }
+    }
+  }
+  linhas.sort((a, b) => Number(b.esperaVoce) - Number(a.esperaVoce) || (a.maquina < b.maquina ? -1 : a.maquina > b.maquina ? 1 : 0) ||
+    (a.thread < b.thread ? -1 : a.thread > b.thread ? 1 : 0))
+  return { lidoEm: agora, linhas: linhas.slice(0, TETO_DE_LINHAS_DA_REDE), maquinas, lacunas, erro: null }
+}
+
+/** A leitura que falhou guarda o que havia e diz o motivo. */
+export function redeComErro(anterior: TorreRede | null | undefined, erro: string): TorreRede {
+  return { lidoEm: anterior?.lidoEm ?? null, linhas: anterior?.linhas ?? [], maquinas: anterior?.maquinas ?? 0,
+    lacunas: anterior?.lacunas ?? 0, erro }
+}
+
+function cortar(texto: string, teto: number): string {
+  const limpo = texto.replace(/\s+/g, ' ').trim()
+  return limpo.length <= teto ? limpo : `${limpo.slice(0, teto - 1)}…`
+}
+
+/**
+ * A linha da faixa (D9): as threads abertas e o que pede acao primeiro (quem espera o dono e as paradas,
+ * com a primeira de cada), a rede quando lida e o aviso de lista velha. Sem quadro lido, nenhuma linha (a
+ * faixa fica com os outros).
+ */
+export function textoDaFaixa(q: TorreQuadro, rede: TorreRede | null): string | undefined {
+  if (q.lidoEm === null) return undefined
+  const total = q.linhas.length + q.omitidas
+  const partes = [total === 0 ? 'nenhuma thread aberta nesta máquina' : total === 1 ? '1 thread aberta' : `${total} threads abertas`]
+  const espera = q.linhas.filter(l => l.estado === 'espera-voce')
+  const paradas = q.linhas.filter(l => l.estado === 'parada')
+  const andando = q.linhas.filter(l => l.estado === 'andando').length
+  if (espera.length) partes.push(`${espera.length} ${espera.length === 1 ? 'espera' : 'esperam'} você (${espera[0]?.thread})`)
+  if (paradas.length) {
+    const p = paradas[0]
+    partes.push(`${paradas.length} ${paradas.length === 1 ? 'parada' : 'paradas'} (${p?.thread}: ${p?.bloqueio?.frase ?? '?'})`)
+  }
+  if (!espera.length && !paradas.length && andando) partes.push(`${andando} andando`)
+  if (rede && rede.lidoEm !== null) {
+    const esperaNaRede = rede.linhas.filter(l => l.esperaVoce).length
+    partes.push(`rede: ${rede.linhas.length} em outras máquinas${esperaNaRede ? `, ${esperaNaRede} espera você` : ''}`)
+  }
+  if (q.erro) partes.push('lista não relida')
+  return cortar(partes.join(' · '), TETO_DO_TEXTO_DA_FAIXA)
+}