@orkastery/cli 0.5.3 → 0.6.0

package/adapters/claude-code/mods/ork-mesa/hooks/cartoes.tsx

@@ -0,0 +1,246 @@
+// Os cartoes da Mesa do Dono (RM-059 F5; D4 da thread ork-rm059mesa), em funcoes puras: a fila vira linhas da tela,
+// uma por elemento, e as linhas viram a arvore do painel com os elementos que a superficie resolveu. Cada pergunta
+// traz a recomendada primeiro, com o porque, depois as outras alternativas com a consequencia; a decisao que a
+// fabrica (ou a Mesa) tomou pelo dono traz o que, o porque, como mudar e o custo de reverter. O unico botao com
+// efeito e o Decidir, que so pede ao nucleo o dialogo nativo do pedido. So importa tipos e modulos puros da Mesa.
+import type { MesaDecidindo, MesaDecisao, MesaFila, MesaObvia, MesaOutro, MesaPergunta } from '../types'
+import { duracao, esperamODono, MAXIMO_DE_DECISOES, MAXIMO_DE_OUTROS, TAMANHO_DO_LOTE } from './fila'
+import { FALHA_DA_CONDICAO, testeDaObvia } from './obvia'
+
+export type MesaMostrado = { chave: string; thread: string | null; texto: string }
+
+export type LinhaDaMesa = {
+  tipo: 'titulo' | 'aviso' | 'foco' | 'secao' | 'cabecalho' | 'texto' | 'dim' | 'decidir' | 'nav'
+  chave: string
+  texto: string
+  /** O pedido do botao Decidir. */
+  pedidoId?: string
+  /** O que vai ao registro do mostrado da ponte quando a linha esta na janela de rolagem do painel a vista. */
+  mostrado?: MesaMostrado
+}
+
+export type EstadoDaMesa = {
+  fila: MesaFila
+  foco: string | null
+  pagina: number
+  decidindo: Readonly<Record<string, MesaDecidindo>>
+  obvias: Readonly<Record<string, MesaObvia>>
+}
+
+function plural(n: number, um: string, varios: string): string {
+  return `${n} ${n === 1 ? um : varios}`
+}
+
+/** O prazo como o dono le: o horario local que o nucleo mandou, ou quanto falta. */
+function textoDoPrazo(p: MesaPergunta, agora: number): string | null {
+  if (p.prazoLocal) return `prazo ${p.prazoLocal}`
+  const t = Date.parse(p.prazo ?? '')
+  if (!Number.isFinite(t)) return null
+  return t > agora ? `vence em ${duracao(t - agora)}` : `venceu há ${duracao(agora - t)}`
+}
+
+/** As paginas do lote de perguntas, e a pagina pedida dentro delas. */
+export function paginaDoLote(total: number, pagina: number): { pagina: number; paginas: number } {
+  const paginas = Math.max(1, Math.ceil(total / TAMANHO_DO_LOTE))
+  return { pagina: Math.min(Math.max(0, Math.floor(pagina) || 0), paginas - 1), paginas }
+}
+
+/** O cartao de uma pergunta. */
+export function linhasDaPergunta(p: MesaPergunta, e: EstadoDaMesa, agora: number): LinhaDaMesa[] {
+  const k = (s: string) => `${p.pedidoId}:${s}`
+  const obvia = e.obvias[p.pedidoId]
+  const decidida = obvia?.estado === 'registrada'
+  const decidindo = e.decidindo[p.pedidoId]
+  const cabecalho = [p.thread, p.fase, p.codigo ? `código ${p.codigo}` : null, textoDoPrazo(p, agora)].filter(Boolean).join(' · ')
+  const linhas: LinhaDaMesa[] = [{
+    tipo: 'cabecalho', chave: k('cabecalho'), texto: `${decidida ? '✓' : '?'} ${cabecalho}`,
+    mostrado: { chave: `hitl:${p.pedidoId}`, thread: p.thread, texto: `${p.thread}: espera você: ${p.pergunta}` },
+  }]
+  linhas.push({ tipo: 'texto', chave: k('pergunta'), texto: `  ${p.pergunta}` })
+  if (decidida) {
+    linhas.push({ tipo: 'texto', chave: k('obvia'), texto: `  decidido sem te chamar: segue a recomendada no prazo; ${comoMudarDaObvia(p, agora)}` })
+  } else if (obvia?.estado === 'incerta') {
+    linhas.push({ tipo: 'dim', chave: k('obvia'), texto: '  a Mesa pediu ao núcleo a decisão óbvia e confere na próxima leitura se ela foi gravada' })
+  } else if (obvia?.estado === 'recusada') {
+    linhas.push({ tipo: 'aviso', chave: k('obvia'), texto: `  a Mesa não decidiu: ${obvia.texto}` })
+  } else if (!p.conferida) {
+    linhas.push({ tipo: 'dim', chave: k('porque-pergunta'), texto: '  não conferido no núcleo agora: sem Decidir e sem decisão óbvia; use a reserva' })
+  } else {
+    // Sem criterio escrito e o caso de todo gate que espera o dono: dizer isso em cada cartao so repetiria a regra.
+    const teste = testeDaObvia(p, agora)
+    const motivo = teste.obvia ? undefined : teste.falhou[0]
+    if (motivo && motivo !== 'criterio') linhas.push({ tipo: 'dim', chave: k('porque-pergunta'), texto: `  pergunta: ${FALHA_DA_CONDICAO[motivo]}` })
+  }
+  const recomendada = p.alternativas.find(a => a.recomendada)
+  if (recomendada) {
+    linhas.push({ tipo: 'texto', chave: k('recomendada'), texto: `  Recomendada: ${recomendada.chave}) ${recomendada.texto}` })
+    if (recomendada.porque) linhas.push({ tipo: 'dim', chave: k('porque'), texto: `    porque: ${recomendada.porque}` })
+    if (recomendada.consequencia) linhas.push({ tipo: 'dim', chave: k('consequencia'), texto: `    se escolher: ${recomendada.consequencia}` })
+  } else if (p.recomendacao) {
+    linhas.push({ tipo: 'texto', chave: k('recomendada'), texto: `  Recomendação: ${p.recomendacao}` })
+  }
+  for (const a of p.alternativas) {
+    if (a.recomendada) continue
+    linhas.push({ tipo: 'dim', chave: k(`alt:${a.chave}`), texto: `  ${a.chave}) ${a.texto}${a.consequencia ? `: ${a.consequencia}` : ''}` })
+  }
+  if (p.irreversivel) linhas.push({ tipo: 'aviso', chave: k('sem-volta'), texto: `  sem volta: ${p.ato ?? 'ato irreversível'}` })
+  if (decidindo?.estado === 'abrindo') {
+    linhas.push({ tipo: 'texto', chave: k('decidindo'), texto: '  diálogo pedido: responda na janela do Claude Code' })
+  } else {
+    if (decidindo) linhas.push({ tipo: decidindo.estado === 'erro' ? 'aviso' : 'dim', chave: k('decidindo'), texto: `  ${decidindo.texto}` })
+    if (p.canalClaudeCode === 'disponivel') linhas.push({ tipo: 'decidir', chave: `decidir:${p.pedidoId}`, texto: 'Decidir', pedidoId: p.pedidoId })
+  }
+  if (p.reserva) {
+    const telegram = p.contrato === 'ork.hitl/v2' && p.alvo === 'gate' && p.codigo !== null
+    linhas.push({ tipo: 'dim', chave: k('reserva'), texto: telegram ? `  reserva: ${p.reserva} pelo Telegram` : `  reserva: ${p.reserva}` })
+  }
+  return linhas
+}
+
+/** Como o dono muda a decisao obvia que a Mesa registrou: o Decidir ou a reserva antes do prazo; depois dele, nada. */
+function comoMudarDaObvia(p: MesaPergunta, agora: number): string {
+  const prazo = Date.parse(p.prazo ?? '')
+  if (Number.isFinite(prazo) && prazo <= agora) return 'o prazo passou e a recomendada seguiu'
+  return p.canalClaudeCode === 'disponivel' ? 'para mudar, Decidir antes do prazo' : 'para mudar, use a reserva antes do prazo'
+}
+
+/** O cartao de uma decisao que a fabrica (ou a Mesa) tomou sem chamar o dono. */
+export function linhasDaDecisao(d: MesaDecisao, agora: number): LinhaDaMesa[] {
+  const k = (s: string) => `${d.id}:${s}`
+  const em = Date.parse(d.em)
+  const quando = Number.isFinite(em) ? ` · há ${duracao(agora - em)}` : ''
+  const marca = d.revertidaPor ? ' · revertida' : d.nova ? ' · nova' : ''
+  return [
+    { tipo: 'cabecalho', chave: k('cabecalho'), texto: `${d.revertidaPor ? '↺' : '✓'} ${d.thread} · ${d.fase}${quando}${marca}`,
+      mostrado: { chave: `decisao:${d.id}`, thread: d.thread || null, texto: `${d.thread}: decidido sem te chamar: ${d.decidido}` } },
+    { tipo: 'texto', chave: k('decidido'), texto: `  ${d.decidido}` },
+    ...(d.revertidaPor ? [{ tipo: 'aviso' as const, chave: k('revertida'), texto: `  desfeita pela decisão ${d.revertidaPor.slice(0, 8)}` }] : []),
+    ...(d.reverte ? [{ tipo: 'dim' as const, chave: k('reverte'), texto: `  desfaz a decisão ${d.reverte.slice(0, 8)}` }] : []),
+    { tipo: 'dim', chave: k('porque'), texto: `  porque: ${d.porque}` },
+    { tipo: 'dim', chave: k('como-mudar'), texto: `  como mudar: ${d.comoMudar}` },
+    { tipo: 'dim', chave: k('custo'), texto: `  reverter: agora, ${d.custoAgora}; depois, ${d.custoDepois}` },
+    { tipo: 'dim', chave: k('quem'), texto: `  quem decidiu: ${d.quemDecidiu}` },
+  ]
+}
+
+/** O cartao de uma parada sem pedido ou de um impedimento: so leitura, com a recomendacao e o comando. */
+export function linhasDoOutro(o: MesaOutro, agora: number): LinhaDaMesa[] {
+  const k = (s: string) => `${o.chave}:${s}`
+  const desde = Date.parse(o.desdeEm ?? '')
+  const partes = [o.thread ?? 'sem thread', o.fase, o.motivo, Number.isFinite(desde) ? `há ${duracao(agora - desde)}` : null,
+    o.impedimento ? 'só você resolve' : null].filter(Boolean)
+  const linhas: LinhaDaMesa[] = [{
+    tipo: 'cabecalho', chave: k('cabecalho'), texto: `! ${partes.join(' · ')}`,
+    mostrado: { chave: `parada:${o.chave}`, thread: o.thread, texto: `${o.thread ?? 'sem thread'}: ${o.motivo}: ${o.texto}` },
+  }]
+  if (o.texto) linhas.push({ tipo: 'texto', chave: k('texto'), texto: `  ${o.texto}` })
+  if (o.recomendacao) linhas.push({ tipo: 'dim', chave: k('recomendacao'), texto: `  recomendação: ${o.recomendacao}` })
+  if (o.comando && o.comando !== o.recomendacao) linhas.push({ tipo: 'dim', chave: k('comando'), texto: `  comando: ${o.comando}` })
+  return linhas
+}
+
+/** As linhas do painel: o placar, o foco, as perguntas do lote, as decisoes por voce e as paradas. */
+export function linhasDaMesa(e: EstadoDaMesa, opcoes: { agora: number }): LinhaDaMesa[] {
+  const { fila, foco } = e
+  const agora = opcoes.agora
+  const daThread = <T extends { thread: string | null }>(xs: readonly T[]): T[] => (foco ? xs.filter(x => x.thread === foco) : [...xs])
+  const perguntas = daThread(fila.perguntas)
+  const decisoes = daThread(fila.decisoes)
+  const outros = daThread(fila.outros)
+  const esperam = esperamODono({ ...fila, perguntas }, e.obvias)
+  const desde = esperam.map(p => Date.parse(p.desdeEm ?? '')).filter(Number.isFinite)
+  const novas = decisoes.filter(d => d.nova).length
+  const placar = [
+    `${plural(esperam.length, 'espera', 'esperam')} você${desde.length ? ` (a mais antiga há ${duracao(agora - Math.min(...desde))})` : ''}`,
+    `${plural(decisoes.length, 'decidida', 'decididas')} sem te chamar${novas ? ` (${plural(novas, 'nova', 'novas')})` : ''}`,
+    plural(outros.length, 'parada', 'paradas'),
+    fila.lidoEm === null ? 'ainda não li a fila' : `lido há ${duracao(agora - fila.lidoEm)}`,
+  ]
+  const linhas: LinhaDaMesa[] = [{ tipo: 'titulo', chave: 'titulo', texto: placar.join(' · ') }]
+  if (fila.erro) linhas.push({ tipo: 'aviso', chave: 'erro', texto: `não reli a fila: ${fila.erro}` })
+  fila.avisos.forEach((a, i) => linhas.push({ tipo: 'aviso', chave: `aviso:${i}`, texto: a }))
+  if (foco) linhas.push({ tipo: 'foco', chave: 'foco', texto: `só ${foco}` })
+
+  // A secao lista todo pedido aberto; o placar conta so os que esperam o dono (a decisao obvia nao espera).
+  linhas.push({ tipo: 'secao', chave: 'secao-perguntas', texto: 'Pedidos abertos' })
+  if (!perguntas.length) linhas.push({ tipo: 'dim', chave: 'sem-perguntas', texto: '  nenhum pedido aberto agora' })
+  const { pagina, paginas } = paginaDoLote(perguntas.length, e.pagina)
+  for (const p of perguntas.slice(pagina * TAMANHO_DO_LOTE, (pagina + 1) * TAMANHO_DO_LOTE)) linhas.push(...linhasDaPergunta(p, e, agora))
+  if (paginas > 1) linhas.push({ tipo: 'nav', chave: 'nav', texto: `lote ${pagina + 1} de ${paginas}` })
+
+  linhas.push({ tipo: 'secao', chave: 'secao-decisoes', texto: 'Decididas sem te chamar' })
+  if (!decisoes.length) linhas.push({ tipo: 'dim', chave: 'sem-decisoes', texto: '  nenhuma decisão tomada sem te chamar na janela do pulse' })
+  for (const d of decisoes.slice(0, MAXIMO_DE_DECISOES)) linhas.push(...linhasDaDecisao(d, agora))
+  if (decisoes.length > MAXIMO_DE_DECISOES) {
+    linhas.push({ tipo: 'dim', chave: 'mais-decisoes', texto: `  e mais ${decisoes.length - MAXIMO_DE_DECISOES} na janela do pulse (7 dias)` })
+  }
+
+  if (outros.length) {
+    linhas.push({ tipo: 'secao', chave: 'secao-outros', texto: 'Paradas e impedimentos' })
+    for (const o of outros.slice(0, MAXIMO_DE_OUTROS)) linhas.push(...linhasDoOutro(o, agora))
+    if (outros.length > MAXIMO_DE_OUTROS) linhas.push({ tipo: 'dim', chave: 'mais-outros', texto: `  e mais ${outros.length - MAXIMO_DE_OUTROS}` })
+  }
+  return linhas
+}
+
+/**
+ * O que o desenho poe na janela de rolagem e vai ao registro do mostrado: so linha com `mostrado` cuja posicao esta
+ * entre `offset` e `offset + bodyRows`. Sem janela, nada: o que nao estava na tela nao conta como visto.
+ */
+export function mostradosVisiveis(linhas: readonly LinhaDaMesa[], janela: { offset: number; bodyRows: number } | undefined): MesaMostrado[] {
+  if (!janela || !(janela.bodyRows > 0)) return []
+  const fim = janela.offset + janela.bodyRows
+  return linhas.flatMap((l, i) => (l.mostrado && i >= janela.offset && i < fim ? [l.mostrado] : []))
+}
+
+export type AcoesDaMesa = {
+  decidir?: (pedidoId: string) => void
+  atualizar?: () => void
+  verTodas?: () => void
+  anteriores?: () => void
+  proximas?: () => void
+}
+
+/** A arvore do painel com os elementos que a superficie resolveu (`$.ui.resolve(e)` no register.tsx). */
+export function desenharMesa(el: { Box: any; Text: any; Button: any }, linhas: readonly LinhaDaMesa[], acoes: AcoesDaMesa) {
+  const { Box, Text, Button } = el
+  return (
+    <Box flexDirection="column">
+      {linhas.map(l => {
+        if (l.tipo === 'titulo') {
+          return (
+            <Box key="titulo" flexDirection="row">
+              <Text key="placar" bold wrap="truncate">{l.texto}</Text>
+              <Button key="atualizar" label="Atualizar" onPress={() => acoes.atualizar?.()} />
+            </Box>
+          )
+        }
+        if (l.tipo === 'foco') {
+          return (
+            <Box key="foco" flexDirection="row">
+              <Text key="foco-texto" dimColor wrap="truncate">{l.texto}</Text>
+              <Button key="ver-todas" label="Ver todas" onPress={() => acoes.verTodas?.()} />
+            </Box>
+          )
+        }
+        if (l.tipo === 'nav') {
+          return (
+            <Box key="nav" flexDirection="row">
+              <Button key="anteriores" label="Anteriores" onPress={() => acoes.anteriores?.()} />
+              <Text key="nav-texto" dimColor wrap="truncate">{l.texto}</Text>
+              <Button key="proximas" label="Próximas" onPress={() => acoes.proximas?.()} />
+            </Box>
+          )
+        }
+        if (l.tipo === 'decidir') {
+          const pedidoId = l.pedidoId ?? ''
+          return <Button key={l.chave} label="Decidir" onPress={() => acoes.decidir?.(pedidoId)} />
+        }
+        if (l.tipo === 'secao' || l.tipo === 'cabecalho') return <Text key={l.chave} bold wrap="truncate">{l.texto}</Text>
+        if (l.tipo === 'aviso') return <Text key={l.chave} color="warning" wrap="truncate">{l.texto}</Text>
+        if (l.tipo === 'dim') return <Text key={l.chave} dimColor wrap="truncate">{l.texto}</Text>
+        return <Text key={l.chave} wrap="truncate">{l.texto}</Text>
+      })}
+    </Box>
+  )
+}

package/adapters/claude-code/mods/ork-mesa/hooks/decidir.ts

@@ -0,0 +1,110 @@
+// O que a Mesa do Dono manda ao nucleo (RM-059 F5; D6 e D7 da thread ork-rm059mesa), em funcoes puras. Sao so duas
+// ferramentas com efeito e uma de leitura, todas no servidor `orkastery`:
+//  - `ork_request_decision` recebe exatamente `threadId` e `pedidoId`: o nucleo abre o dialogo nativo do host e grava
+//    a resposta que o dono der, com o recibo do ingresso local. A Mesa nunca manda opcao, letra nem texto.
+//  - `ork_decision_record` registra a decisao obvia (teste das quatro condicoes) como decisao autonoma do nucleo,
+//    com criterio, evidencia, como mudar e o custo de reverter. Nao responde o pedido.
+//  - `ork_hitl_pending` le os pedidos abertos de uma thread.
+// So importa tipos.
+import type { MesaDecidindo, MesaDecisao, MesaPergunta } from '../types'
+
+export const SERVIDOR = 'orkastery'
+/** A lista fechada de ferramentas do nucleo que a Mesa chama (D2 e D7). */
+export const FERRAMENTAS_DA_MESA: readonly string[] = ['ork_hitl_pending', 'ork_request_decision', 'ork_decision_record']
+/** Quem decidiu, no rastro do nucleo: a Mesa, nunca o dono (o nucleo recusa rastro que comeca pelo dono). */
+export const QUEM_DECIDIU = 'mod ork-mesa na sessão do dono, pelo teste das quatro condições'
+/** Os tetos do nucleo para a decisao informada (`TETOS_HITL_V2` e o esquema do `ork_decision_record`). */
+export const TETO_DO_CAMPO = 200
+export const TETO_DO_CUSTO = 140
+export const TETO_DA_REFERENCIA = 300
+
+/** Uma linha so, cortada no teto, para caber no contrato do nucleo. */
+export function linhaNoTeto(v: string, teto: number): string {
+  const t = v.replace(/\s+/g, ' ').trim()
+  return t.length <= teto ? t : `${t.slice(0, teto - 1).trimEnd()}…`
+}
+
+/** Os argumentos do Decidir: so os dois ids, nada que seja resposta. */
+export function argsDoDecidir(p: Pick<MesaPergunta, 'thread' | 'pedidoId'>): { threadId: string; pedidoId: string } {
+  return { threadId: p.thread, pedidoId: p.pedidoId }
+}
+
+/** A marca do pedido no texto da decisao obvia: e por ela que a Mesa sabe que ja decidiu este pedido. */
+export function marcaDoPedido(pedidoId: string): string {
+  return `(${pedidoId.slice(0, 8)})`
+}
+
+/** Ja existe, na janela do pulse, a decisao obvia que a Mesa registrou para este pedido. */
+export function jaDecidida(decisoes: readonly MesaDecisao[], p: Pick<MesaPergunta, 'thread' | 'pedidoId'>): boolean {
+  const marca = marcaDoPedido(p.pedidoId)
+  return decisoes.some(d => d.thread === p.thread && d.quemDecidiu.startsWith('mod ork-mesa') && d.decidido.includes(marca))
+}
+
+export type ArgsDaDecisaoObvia = {
+  threadId: string
+  decidido: string
+  porque: string
+  comoMudar: string
+  custoAgora: string
+  custoDepois: string
+  criterio: { tipo: 'medicao'; referencia: string }
+  quemDecidiu: string
+  evidencia: string
+}
+
+/**
+ * Os argumentos do `ork_decision_record` para uma decisao obvia: o que, o porque, como mudar, o custo de reverter
+ * antes e depois do prazo, o criterio (a medicao que mostra o pedido declarando `seguir-recomendada`) e a evidencia
+ * (a leitura do `ork_hitl_pending`). Cada campo cabe nos tetos do nucleo, numa linha.
+ */
+export function argsDaDecisaoObvia(p: MesaPergunta, recomendada: { chave: string; texto: string }, referencia: string,
+  lidoEmIso: string): ArgsDaDecisaoObvia {
+  const pedido = p.codigo ?? p.pedidoId.slice(0, 8)
+  const prazo = p.prazoLocal ?? p.prazo ?? 'no prazo do pedido'
+  const reserva = p.reserva ? ` ou ${p.reserva} pelo Telegram` : ''
+  return {
+    threadId: p.thread,
+    decidido: linhaNoTeto(`Sem te chamar: o pedido ${pedido} ${marcaDoPedido(p.pedidoId)} da ${p.thread} segue a recomendada ` +
+      `${recomendada.chave} (${recomendada.texto}) no prazo ${prazo}`, TETO_DO_CAMPO),
+    porque: linhaNoTeto('O pedido declara que segue a recomendada no prazo, é reversível antes da entrega e passou nas quatro ' +
+      'condições da decisão óbvia (M4)', TETO_DO_CAMPO),
+    comoMudar: linhaNoTeto(`Na Mesa, Decidir no cartão do pedido ${pedido} antes do prazo${reserva}`, TETO_DO_CAMPO),
+    custoAgora: linhaNoTeto('Nenhum: o pedido segue aberto até o prazo e o dono escolhe outra alternativa no diálogo', TETO_DO_CUSTO),
+    custoDepois: linhaNoTeto('Depois do prazo a recomendada já seguiu; mudar pede nova decisão na thread', TETO_DO_CUSTO),
+    criterio: { tipo: 'medicao', referencia: linhaNoTeto(referencia, TETO_DA_REFERENCIA) },
+    quemDecidiu: QUEM_DECIDIU,
+    evidencia: linhaNoTeto(`ork_hitl_pending ${p.thread} lido em ${lidoEmIso}: pedido ${p.pedidoId}, estado ${p.estado}, ` +
+      `acaoPadraoAoExpirar ${p.acaoAoExpirar ?? '-'}, irreversivel ${String(p.irreversivel)}, fase ${p.fase ?? '-'}`, 4096),
+  }
+}
+
+/**
+ * Depois de uma recarga do modulo nenhum Decidir esta em curso: o que ficou `abrindo` no estado vira `sem-resposta`,
+ * e o cartao volta a ter o botao.
+ */
+export function soltarAbrindo(decidindo: Readonly<Record<string, MesaDecidindo>>): Record<string, MesaDecidindo> {
+  return Object.fromEntries(Object.entries(decidindo).map(([id, v]) => [id, v.estado === 'abrindo'
+    ? { estado: 'sem-resposta' as const, texto: 'o diálogo ficou sem resposta (a Mesa recarregou); o pedido segue aberto', em: v.em } : v]))
+}
+
+/** Por que a notificacao do sistema nao saiu, em pt-BR (o motor manda o codigo em ingles). */
+export function motivoDaNotificacao(reason: unknown): string {
+  const motivos: Record<string, string> = {
+    'no-channel': 'nenhum canal de notificação configurado',
+    'no-surface': 'nenhuma superfície para mostrar',
+    refused: 'o terminal recusou a notificação',
+    disabled: 'as notificações estão desligadas',
+  }
+  return `a notificação do sistema não saiu (${motivos[String(reason)] ?? String(reason)})`
+}
+
+/** O que o cartao diz do Decidir, a partir do que o nucleo devolveu (`{ ok, pedidoId, estado, repetida }`). */
+export function resultadoDoDecidir(resposta: unknown, agora: number): MesaDecidindo {
+  const r = (resposta && typeof resposta === 'object' ? resposta : {}) as { ok?: unknown; estado?: unknown; repetida?: unknown }
+  const estado = typeof r.estado === 'string' ? r.estado : ''
+  if (r.ok === true) {
+    if (r.repetida === true) return { estado: 'respondido', texto: `o pedido já estava respondido no núcleo: ${estado || 'registrado'}`, em: agora }
+    return { estado: 'respondido', texto: `respondido pelo diálogo: ${estado || 'registrado'}`, em: agora }
+  }
+  return { estado: 'sem-resposta', texto: 'o diálogo fechou sem resposta; o pedido segue aberto', em: agora }
+}

package/adapters/claude-code/mods/ork-mesa/hooks/fila.ts

@@ -0,0 +1,253 @@
+// A fila da Mesa do Dono (RM-059 F5), em funcoes puras: o que o pulse, o retrato e o `ork_hitl_pending` do nucleo
+// trazem vira pergunta, parada ou decisao, e a faixa sai daqui. So importa tipos: o register.tsx le o nucleo pela
+// ponte e entrega os objetos a estas funcoes. Nada aqui responde pedido nem escolhe opcao pelo dono.
+import type { MesaAlternativa, MesaCanal, MesaDecisao, MesaFila, MesaObvia, MesaOutro, MesaPergunta } from '../types'
+
+/** Perguntas por pagina: o lote de ate cinco da RM-041 e da RM-057. */
+export const TAMANHO_DO_LOTE = 5
+/** Decisoes informadas que o painel mostra por inteiro; o resto vira uma linha com a contagem. */
+export const MAXIMO_DE_DECISOES = 5
+/** Paradas e impedimentos que o painel mostra por inteiro. */
+export const MAXIMO_DE_OUTROS = 5
+/** So a decisao das ultimas 24 h que a Mesa ainda nao mostrou conta como nova. */
+export const JANELA_DE_NOVAS_MS = 24 * 60 * 60 * 1000
+export const TETO_DO_TEXTO = 200
+export const TETO_DA_FAIXA = 200
+const ID = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+
+export const FILA_VAZIA: MesaFila = { perguntas: [], outros: [], decisoes: [], totalDeDecisoes: 0, lidoEm: null, erro: null, avisos: [] }
+
+type Bruto = Record<string, unknown>
+const objeto = (v: unknown): v is Bruto => !!v && typeof v === 'object' && !Array.isArray(v)
+const texto = (v: unknown): string => (typeof v === 'string' ? v : '')
+const textoOuNulo = (v: unknown): string | null => (typeof v === 'string' && v.trim() !== '' ? v : null)
+
+/** Uma linha so, sem quebra e sem espaco repetido, cortada no teto. */
+export function umaLinha(v: unknown, teto = TETO_DO_TEXTO): string {
+  const t = texto(v).replace(/\s+/g, ' ').trim()
+  return t.length <= teto ? t : `${t.slice(0, teto - 1).trimEnd()}…`
+}
+
+/** Quanto tempo, como o dono le: segundos, minutos, horas e dias. */
+export function duracao(ms: number): string {
+  const s = Math.max(0, Math.floor(ms / 1000))
+  if (s < 60) return `${s} s`
+  const min = Math.floor(s / 60)
+  if (min < 60) return `${min} min`
+  const h = Math.floor(min / 60)
+  if (h < 48) return `${h} h`
+  return `${Math.floor(h / 24)} dias`
+}
+
+/** O texto que um JSON traz, ou `undefined` quando nao e JSON. */
+function lerJson(t: string): unknown {
+  try {
+    return JSON.parse(t)
+  } catch {
+    return undefined
+  }
+}
+
+/** O JSON que uma ferramenta MCP do nucleo devolve no primeiro bloco de texto; erro vira excecao com o motivo. */
+export function jsonDoMcp(r: unknown): unknown {
+  const bruto = (objeto(r) ? r : {}) as { content?: unknown; isError?: unknown }
+  const blocos = Array.isArray(bruto.content) ? bruto.content.filter(objeto) : []
+  const corpo = blocos.find(c => c.type === 'text' && typeof c.text === 'string')?.text as string | undefined
+  if (bruto.isError === true) {
+    const j = corpo === undefined ? undefined : lerJson(corpo)
+    throw new Error(umaLinha(objeto(j) && typeof j.erro === 'string' ? j.erro : corpo ?? 'o nucleo respondeu com erro'))
+  }
+  if (corpo === undefined) throw new Error('o nucleo nao devolveu texto')
+  const j = lerJson(corpo)
+  if (j === undefined) throw new Error('o nucleo devolveu texto que nao e JSON')
+  return j
+}
+
+/** As alternativas de um pedido: letras no `ork.hitl/v2`, numeros no `ork.hitl/v1`, como o nucleo as declara. */
+export function alternativasDoPedido(p: Bruto): MesaAlternativa[] {
+  if (p.contrato === 'ork.hitl/v2' && Array.isArray(p.alternativas)) {
+    return p.alternativas.filter(objeto).map(a => ({
+      chave: texto(a.letra), texto: umaLinha(a.texto), acao: texto(a.acao), consequencia: textoOuNulo(a.consequencia),
+      recomendada: a.recomendada === true, porque: textoOuNulo(a.porque),
+    }))
+  }
+  if (Array.isArray(p.opcoes)) {
+    return p.opcoes.filter(objeto).map(o => ({
+      chave: typeof o.numero === 'number' ? String(o.numero) : texto(o.numero), texto: umaLinha(o.texto), acao: texto(o.acao),
+      consequencia: null, recomendada: false, porque: null,
+    }))
+  }
+  return []
+}
+
+/**
+ * A pergunta de um pedido aberto (`ork.hitl/v1`, ou `ork.hitl/v2` de classe `pergunta`); `null` para o que nao e
+ * pergunta (a decisao informada nao pede nada) ou nao tem identificacao valida.
+ */
+export function perguntaDoPedido(pedido: unknown, extra: { desdeEm?: string | null; reserva?: string | null } = {}): MesaPergunta | null {
+  if (!objeto(pedido)) return null
+  const v2 = pedido.contrato === 'ork.hitl/v2'
+  if (!v2 && pedido.contrato !== 'ork.hitl/v1') return null
+  if (v2 && pedido.classe !== 'pergunta') return null
+  const alvo = objeto(pedido.alvo) ? pedido.alvo.tipo : undefined
+  if (alvo !== 'gate' && alvo !== 'session') return null
+  const thread = texto(pedido.thread)
+  const id = texto(pedido.id)
+  if (!ID.test(thread) || !ID.test(id)) return null
+  const alternativas = alternativasDoPedido(pedido)
+  const recomendada = alternativas.find(a => a.recomendada)
+  const codigo = v2 ? textoOuNulo(pedido.codigo) : null
+  return {
+    thread, fase: textoOuNulo(pedido.fase), modo: textoOuNulo(pedido.modo), pedidoId: id, codigo,
+    contrato: v2 ? 'ork.hitl/v2' : 'ork.hitl/v1', alvo, motivo: texto(pedido.motivo), pergunta: umaLinha(pedido.pergunta),
+    recomendacao: v2 ? (recomendada ? `${recomendada.chave}) ${recomendada.texto}` : '') : umaLinha(pedido.recomendacao),
+    alternativas, irreversivel: pedido.irreversivel === true, ato: textoOuNulo(pedido.ato),
+    tipoDeResposta: v2 ? textoOuNulo(pedido.tipoDeResposta) : null,
+    respostaAceita: objeto(pedido.respostaAceita) ? textoOuNulo(pedido.respostaAceita.tipo) : null,
+    dependenciaTecnica: pedido.dependenciaTecnica !== undefined, acaoAoExpirar: textoOuNulo(pedido.acaoPadraoAoExpirar),
+    prazo: textoOuNulo(pedido.prazo), prazoLocal: null, desdeEm: extra.desdeEm ?? textoOuNulo(pedido.criadoEm),
+    estado: 'desconhecido', conferida: false, canalClaudeCode: 'desconhecido',
+    reserva: extra.reserva ?? (codigo && recomendada ? `${codigo} ${recomendada.chave}` : null),
+  }
+}
+
+/** As chaves que a Mesa ja registrou na ponte por um canal (`decisao:` no painel, `hitl:` na notificacao), sem o prefixo. */
+function chavesDaMesa(registro: unknown, prefixo: string, canal?: string): Set<string> {
+  const itens = objeto(registro) && Array.isArray(registro.itens) ? registro.itens.filter(objeto) : []
+  const chaves = new Set<string>()
+  for (const i of itens) {
+    const chave = texto(i.chave)
+    if (i.mod === 'ork-mesa' && chave.startsWith(prefixo) && (canal === undefined || i.canal === canal)) chaves.add(chave.slice(prefixo.length))
+  }
+  return chaves
+}
+
+/** Os ids das decisoes que a Mesa ja mostrou ao dono, pelo registro do mostrado da ponte. */
+export function decisoesVistas(registro: unknown): Set<string> {
+  return chavesDaMesa(registro, 'decisao:')
+}
+
+/** Os pedidos que a Mesa ja levou ao dono por notificacao, pelo registro da ponte: valem depois de uma recarga do modulo. */
+export function pedidosNotificados(registro: unknown): Set<string> {
+  return chavesDaMesa(registro, 'hitl:', 'notificacao')
+}
+
+/** A ordem das perguntas: o prazo mais perto primeiro, depois a mais antiga; sem prazo vai para o fim. */
+export function ordenarPerguntas(perguntas: readonly MesaPergunta[]): MesaPergunta[] {
+  const prazo = (p: MesaPergunta) => {
+    const t = Date.parse(p.prazo ?? '')
+    return Number.isFinite(t) ? t : Number.POSITIVE_INFINITY
+  }
+  const desde = (p: MesaPergunta) => {
+    const t = Date.parse(p.desdeEm ?? '')
+    return Number.isFinite(t) ? t : Number.POSITIVE_INFINITY
+  }
+  return [...perguntas].sort((a, b) => prazo(a) - prazo(b) || desde(a) - desde(b) || a.pedidoId.localeCompare(b.pedidoId))
+}
+
+/**
+ * A fila a partir do `ork pulse --json`: as perguntas com pedido, as paradas e os impedimentos de
+ * `precisaDeHumanoAgora`, e as decisoes que a fabrica tomou pelo dono na janela do pulse.
+ */
+export function filaDoPulse(pulse: unknown, vistas: ReadonlySet<string>, agora: number): Omit<MesaFila, 'lidoEm' | 'erro' | 'avisos'> {
+  const p = objeto(pulse) ? pulse : {}
+  const humanos = Array.isArray(p.precisaDeHumanoAgora) ? p.precisaDeHumanoAgora.filter(objeto) : []
+  const perguntas: MesaPergunta[] = []
+  const outros: MesaOutro[] = []
+  for (const item of humanos) {
+    const pergunta = item.pedido === undefined ? null
+      : perguntaDoPedido(item.pedido, { desdeEm: textoOuNulo(item.desdeEm), reserva: textoOuNulo(item.comandoResposta) })
+    if (pergunta) {
+      if (!perguntas.some(x => x.pedidoId === pergunta.pedidoId)) perguntas.push(pergunta)
+      continue
+    }
+    if (item.classe === 'score_pendente') continue
+    const impedimento = objeto(item.impedimento) ? item.impedimento : null
+    outros.push({
+      chave: umaLinha(item.id, 160), thread: textoOuNulo(item.thread), fase: textoOuNulo(item.fase), motivo: texto(item.motivo),
+      texto: umaLinha(item.pergunta), recomendacao: umaLinha(item.recomendacao),
+      comando: umaLinha(impedimento ? impedimento.comando : item.comandoResposta), desdeEm: textoOuNulo(item.desdeEm),
+      impedimento: impedimento !== null,
+    })
+  }
+  const brutas = Array.isArray(p.decisoes) ? p.decisoes.filter(objeto) : []
+  // A decisao que outra desfez continua na janela, marcada como revertida, e nunca conta como nova.
+  const revertidaPor = new Map<string, string>()
+  for (const d of brutas) if (typeof d.reverte === 'string' && ID.test(d.reverte)) revertidaPor.set(d.reverte, texto(d.id))
+  const decisoes: MesaDecisao[] = brutas.flatMap(d => {
+    const id = texto(d.id)
+    if (!ID.test(id)) return []
+    const custo = objeto(d.custoDeReverter) ? d.custoDeReverter : {}
+    const em = texto(d.em)
+    const recente = Number.isFinite(Date.parse(em)) && agora - Date.parse(em) <= JANELA_DE_NOVAS_MS
+    const desfeita = revertidaPor.get(id) ?? null
+    return [{
+      id, thread: texto(d.thread), fase: texto(d.fase), em, decidido: umaLinha(d.decidido), porque: umaLinha(d.porque),
+      comoMudar: umaLinha(d.comoMudar), custoAgora: umaLinha(custo.agora, 140), custoDepois: umaLinha(custo.depois, 140),
+      quemDecidiu: umaLinha(d.quemDecidiu, 120), reverte: typeof d.reverte === 'string' && ID.test(d.reverte) ? d.reverte : null,
+      revertidaPor: desfeita, nova: recente && desfeita === null && !vistas.has(id),
+    }]
+  })
+  decisoes.sort((a, b) => Number(b.nova) - Number(a.nova) || b.em.localeCompare(a.em))
+  return { perguntas: ordenarPerguntas(perguntas), outros, decisoes, totalDeDecisoes: decisoes.length }
+}
+
+/**
+ * A assinatura do retrato da secao `hitl`: cada pedido com o estado dele. Muda quando um pedido abre, e respondido,
+ * vence ou fica velho, e e o sinal barato para reler o pulse.
+ */
+export function assinaturaDoRetrato(retrato: unknown): string {
+  const secoes = objeto(retrato) && objeto(retrato.sections) ? retrato.sections : {}
+  const hitl = objeto(secoes.hitl) ? secoes.hitl : {}
+  const itens = Array.isArray(hitl.items) ? hitl.items.filter(objeto) : []
+  return itens.map(i => `${texto(i.id)}:${texto(i.status)}`).sort().join(',')
+}
+
+/**
+ * Confere a pergunta no `ork_hitl_pending` da thread: o pedido de agora, o estado, o prazo local e a oferta do canal
+ * `claude-code`. Pedido que o nucleo nao lista mais saiu da fila (respondido, substituido ou de outra fase): `null`.
+ */
+export function conferirNoNucleo(pergunta: MesaPergunta, resposta: unknown): MesaPergunta | null {
+  const pendencias = objeto(resposta) && Array.isArray(resposta.pendencias) ? resposta.pendencias.filter(objeto) : []
+  const achada = pendencias.find(x => objeto(x.pedido) && x.pedido.id === pergunta.pedidoId)
+  if (!achada) return null
+  const fresca = perguntaDoPedido(achada.pedido, { desdeEm: pergunta.desdeEm, reserva: pergunta.reserva })
+  if (!fresca) return null
+  const canais = Array.isArray(achada.canais) ? achada.canais.filter(objeto) : []
+  const claudeCode = canais.find(c => c.canal === 'claude-code')
+  const canal: MesaCanal = claudeCode?.estado === 'disponivel' ? 'disponivel' : 'indisponivel'
+  return { ...fresca, estado: textoOuNulo(achada.estado) ?? 'desconhecido', conferida: true, prazoLocal: textoOuNulo(achada.prazoLocal),
+    canalClaudeCode: canal }
+}
+
+/** As threads que tem pergunta na fila, sem repetir, na ordem da fila. */
+export function threadsComPergunta(perguntas: readonly MesaPergunta[]): string[] {
+  return [...new Set(perguntas.map(p => p.thread))]
+}
+
+/**
+ * O que espera o dono de fato: a pergunta que a Mesa decidiu pelo nucleo nao conta, nem a que ainda confere no nucleo
+ * se a decisao chegou (ela volta a esperar o dono se a leitura seguinte nao a mostrar).
+ */
+export function esperamODono(fila: MesaFila, obvias: Readonly<Record<string, MesaObvia>>): MesaPergunta[] {
+  return fila.perguntas.filter(p => {
+    const estado = obvias[p.pedidoId]?.estado
+    return estado !== 'registrada' && estado !== 'incerta'
+  })
+}
+
+/**
+ * A linha da Mesa na faixa: quantos pedidos esperam o dono (com a thread do primeiro), as paradas e as decisoes novas
+ * tomadas por ele. Sem idade no texto, para a linha so mudar quando a fila muda. Sem nada, a linha sai.
+ */
+export function textoDaFaixa(fila: MesaFila, obvias: Readonly<Record<string, MesaObvia>>): string | undefined {
+  if (fila.lidoEm === null) return undefined
+  const partes: string[] = []
+  const esperam = esperamODono(fila, obvias)
+  if (esperam.length) partes.push(`${esperam.length} ${esperam.length === 1 ? 'espera' : 'esperam'} você (${esperam[0]?.thread})`)
+  if (fila.outros.length) partes.push(`${fila.outros.length} ${fila.outros.length === 1 ? 'parada' : 'paradas'}`)
+  const novas = fila.decisoes.filter(d => d.nova).length
+  if (novas) partes.push(`${novas} ${novas === 1 ? 'decidida' : 'decididas'} sem te chamar`)
+  if (!partes.length) return undefined
+  return umaLinha(`mesa: ${partes.join(' · ')}`, TETO_DA_FAIXA)
+}

package/adapters/claude-code/mods/ork-mesa/hooks/hooks.json

@@ -0,0 +1,3 @@
+{
+  "modules": ["./register.tsx"]
+}