@orkastery/cli 0.5.3 → 0.5.6

package/adapters/claude-code/mods/ork-clima/types/index.d.ts

@@ -0,0 +1,80 @@
+// Contrato do Clima de Cota (RM-059, onda 1, F4): os tipos da serie e da previsao das janelas de limite
+// da conta, e o estado do mod. O Clima nao acrescenta noun ao `$`: usa o `$.ork` da `ork-ponte`, que ele
+// lista em `dependencies`. Sem import nem referencia, como o motor exige de um contrato.
+
+/** Um ponto da serie: quando foi lido (ms desde a epoca, relogio do `$.clock`) e o percentual. */
+export type ClimaPonto = {
+  em: number
+  pct: number
+}
+
+/** A serie de uma janela (`five_hour`, `seven_day` ou a de gasto de um gateway), desde que ela renovou. */
+export type ClimaJanela = {
+  kind: string
+  /** Quando renova, em ms desde a epoca; `null` quando o motor nao disse. */
+  renovaEm: number | null
+  pontos: ClimaPonto[]
+}
+
+/** A serie `ork.clima-serie/v1` no `$.store` do mod, que dura entre sessoes. */
+export type ClimaSerie = {
+  formato: 'ork.clima-serie/v1'
+  janelas: ClimaJanela[]
+}
+
+/**
+ * `esgotada`: 100% ou mais. `acaba-antes`: no ritmo atual, acaba antes de renovar. `folga`: o ritmo nao
+ * esgota antes de renovar. `sem-ritmo`: ainda sem leituras para medir o ritmo, ou com uma serie nova demais
+ * para prever tao longe (D15).
+ */
+export type ClimaEstado = 'esgotada' | 'acaba-antes' | 'folga' | 'sem-ritmo'
+
+/** A previsao de uma janela no ritmo atual. */
+export type ClimaPrevisao = {
+  kind: string
+  /** `5 h`, `7 d`, `gasto` ou o proprio `kind`. */
+  rotulo: string
+  /** O percentual da ultima leitura. */
+  pct: number
+  /** Quando a ultima leitura chegou, em ms desde a epoca. */
+  lidaEm: number
+  renovaEm: number | null
+  /** Pontos percentuais por hora no intervalo recente; `null` sem leituras suficientes. */
+  ritmoPorHora: number | null
+  /** Quando acaba no ritmo atual, em ms desde a epoca; `null` sem ritmo que esgote. */
+  acabaEm: number | null
+  estado: ClimaEstado
+}
+
+/** Uma retomada da fila que nao cabe, como a ultima leitura da fila deixou. */
+export type ClimaNaoCabe = {
+  id: string
+  thread: string
+  /** O que vai ao registro do mostrado da ponte (D8). */
+  texto: string
+  /** Se o registro ja aceitou; a que falhou e tentada de novo na medicao seguinte (D15). */
+  registrada: boolean
+}
+
+/** O ultimo problema de uma medicao, que o `/clima` mostra (D15). */
+export type ClimaProblema = {
+  /** O que aconteceu, numa frase que comeca minuscula. */
+  motivo: string
+  /** Quando, em ms desde a epoca; `null` quando nem o relogio respondeu. */
+  em: number | null
+  /** Se veio da leitura: so a proxima leitura boa o limpa. */
+  daLeitura: boolean
+}
+
+declare module 'claude-code' {
+  interface PluginState {
+    'ork-clima': {
+      /** A ultima linha que o Clima publicou na faixa da ponte; `null` depois de tira-la. */
+      faixa: string | null
+      /** As retomadas que nao cabiam na ultima leitura da fila, para as medicoes sem leitura nova (D13). */
+      naoCabem: ClimaNaoCabe[]
+      /** O ultimo problema de medicao, ate uma medicao boa limpa-lo (D15). */
+      problema: ClimaProblema | null
+    }
+  }
+}

package/adapters/claude-code/mods/ork-freio/.claude-plugin/plugin.json

@@ -0,0 +1,14 @@
+{
+  "name": "ork-freio",
+  "version": "0.1.0",
+  "description": "Freio de Lote do Orkastery no Claude Code: na sessão de fase, acha as claims que o lote de ferramentas mexeu, pede ao núcleo a conferência delas no sandbox do verify e devolve o que quebrou no lote seguinte.",
+  "author": {
+    "name": "Orkastery contributors",
+    "url": "https://github.com/orkastery"
+  },
+  "homepage": "https://orkastery.com/",
+  "repository": "https://github.com/orkastery/orkastery",
+  "license": "MIT",
+  "types": "./types/index.d.ts",
+  "dependencies": ["ork-ponte"]
+}

package/adapters/claude-code/mods/ork-freio/hooks/carga.ts

@@ -0,0 +1,160 @@
+// A carga do Freio de Lote (RM-059, F2, T2.1): o que ele le do nucleo para saber quais claims vigiar.
+// Modulo puro: interpreta o que as ferramentas de leitura do servidor `orkastery` devolvem e o retrato
+// da ponte. As chamadas ao `$` ficam no register.ts; nada aqui le `.orkastery/` do disco (D2).
+import type { FreioCarga, FreioClaim } from '../types'
+
+export const SERVIDOR = 'orkastery'
+/**
+ * A lista fechada de ferramentas MCP do Freio (D2): as duas de leitura. O `$.mcp.call` nao pede permissao
+ * ao dono, entao o teste do nucleo confere pela AST que o mod so chama estas.
+ */
+export const FERRAMENTA_DAS_CLAIMS = 'ork_claims_list'
+export const FERRAMENTA_DO_PLANO = 'ork_artifact_read'
+export const FERRAMENTAS_DO_FREIO: readonly string[] = [FERRAMENTA_DAS_CLAIMS, FERRAMENTA_DO_PLANO]
+/** Claims com mais idade que isto sao relidas no lote que precisa delas. */
+export const IDADE_DAS_CLAIMS_MS = 60000
+/** O plano com mais idade que isto e relido no lote que precisa dele. */
+export const IDADE_DO_PLANO_MS = 300000
+
+const ID_DE_CLAIM = /^C\d+$/
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+/** O rotulo de `touch_paths` de uma tarefa nos formatos em uso nos planos; o grupo 1 e o resto da linha. */
+const ROTULO_DE_TOUCH_PATHS = /^\s*(?:[-*+]\s+)?(?:\*\*touch_paths:?\*\*\s*:?|`touch_paths`\s*:|touch_paths\s*:)\s*(.*)$/i
+/** Linha que abre outro item de lista, cabecalho ou cerca de codigo (a mesma regra do verify da tarefa no nucleo). */
+const ABRE_BLOCO = /^\s*(?:[-*+]\s|\d+[.)]\s|#{1,6}\s|```|~~~)/
+const TRECHO = /`([^`]+)`/g
+
+export class ErroDeCarga extends Error {}
+
+/** Os argumentos de cada ferramenta da lista fechada para a thread do despacho. */
+export function argsDaFerramenta(ferramenta: string, thread: string): Record<string, unknown> {
+  if (!ID_DE_THREAD.test(thread)) throw new ErroDeCarga('ork-freio: id de thread invalido')
+  if (ferramenta === FERRAMENTA_DAS_CLAIMS) return { threadId: thread }
+  if (ferramenta === FERRAMENTA_DO_PLANO) return { threadId: thread, tipo: 'plan' }
+  throw new ErroDeCarga(`ork-freio: ferramenta fora da lista fechada: ${ferramenta}`)
+}
+
+/** O JSON do primeiro bloco de texto de um resultado MCP; resultado com erro vira excecao. */
+export function jsonDoMcp(r: unknown, ferramenta: string): unknown {
+  const resultado = r as { content?: ReadonlyArray<{ type?: string; text?: unknown }>; isError?: boolean } | null
+  const texto = (resultado?.content ?? []).find(c => c?.type === 'text' && typeof c.text === 'string')?.text as string | undefined
+  if (resultado?.isError) throw new ErroDeCarga(`ork-freio: ${ferramenta} respondeu com erro${texto ? `: ${texto.slice(0, 200)}` : ''}`)
+  if (texto === undefined) throw new ErroDeCarga(`ork-freio: ${ferramenta} nao devolveu texto`)
+  try {
+    return JSON.parse(texto)
+  } catch {
+    throw new ErroDeCarga(`ork-freio: ${ferramenta} devolveu texto que nao e JSON`)
+  }
+}
+
+/** Caminho relativo normalizado: barras para a frente, sem `./` na frente nem barra no fim. */
+export function normalizar(caminho: string): string {
+  return caminho.trim().replace(/\\/g, '/').replace(/^(?:\.\/)+/, '').replace(/\/+$/, '')
+}
+
+/**
+ * As claims nao retiradas, com o que o Freio precisa: id, arquivo e comandos. O `claims.jsonl` e append-only e
+ * o nucleo ja devolve a versao mais nova de cada claim; se vier repetida, a ultima vence do mesmo jeito.
+ */
+export function claimsDoNucleo(bruto: unknown): FreioClaim[] {
+  if (!Array.isArray(bruto)) throw new ErroDeCarga('ork-freio: a lista de claims nao e lista')
+  const porId = new Map<string, FreioClaim | null>()
+  for (const item of bruto) {
+    const c = item as { id?: unknown; arquivo?: unknown; verificar?: unknown; estado?: unknown } | null
+    if (!c || typeof c.id !== 'string' || !ID_DE_CLAIM.test(c.id)) continue
+    if (c.estado === 'retirada') { porId.set(c.id, null); continue }
+    const comandos = Array.isArray(c.verificar) ? c.verificar.filter((v): v is string => typeof v === 'string' && v.trim() !== '') : []
+    const arquivo = typeof c.arquivo === 'string' && c.arquivo.trim() !== '' ? normalizar(c.arquivo) : null
+    porId.set(c.id, { id: c.id, arquivo, comandos })
+  }
+  return [...porId.values()].filter((c): c is FreioClaim => c !== null)
+    .sort((a, b) => Number(a.id.slice(1)) - Number(b.id.slice(1)))
+}
+
+/**
+ * O maior numero de claim que o nucleo ja deu na thread, retiradas incluidas: claim com numero acima dele foi
+ * cadastrada depois desta leitura, e a rodada nao a tira da fila por nao estar na lista.
+ */
+export function maiorNumeroDeClaim(bruto: unknown): number {
+  if (!Array.isArray(bruto)) return 0
+  let maior = 0
+  for (const item of bruto) {
+    const id = (item as { id?: unknown } | null)?.id
+    if (typeof id === 'string' && ID_DE_CLAIM.test(id)) maior = Math.max(maior, Number(id.slice(1)))
+  }
+  return maior
+}
+
+/** O texto do plano que o `ork_artifact_read` devolve, ou `null` quando a thread ainda nao tem plano. */
+export function textoDoPlano(bruto: unknown): string | null {
+  const documento = bruto as { tipo?: unknown; conteudo?: unknown } | null
+  if (!documento || typeof documento !== 'object') throw new ErroDeCarga('ork-freio: o plano lido nao e objeto')
+  return typeof documento.conteudo === 'string' ? documento.conteudo : null
+}
+
+function ehCaminho(texto: string): boolean {
+  return texto !== '' && !/\s/.test(texto) && !texto.startsWith('-') && !texto.split('/').includes('..')
+}
+
+/**
+ * A uniao dos `touch_paths` de todas as tarefas do plano (D9): os trechos entre crases do item do rotulo inteiro,
+ * como o Markdown o junta e como o nucleo le o verify da tarefa: a linha do rotulo, as linhas mais recuadas que
+ * ela (sub-itens e continuacao quebrada) e a continuacao logo abaixo que nao abre outro bloco. `null` sem plano
+ * ou sem nenhum caminho.
+ */
+export function touchPathsDoPlano(conteudo: string | null): string[] | null {
+  if (typeof conteudo !== 'string') return null
+  const achados = new Set<string>()
+  const juntar = (texto: string) => {
+    for (const m of texto.matchAll(TRECHO)) {
+      const caminho = normalizar(m[1] as string)
+      if (ehCaminho(caminho)) achados.add(caminho)
+    }
+  }
+  let recuoDoRotulo = -1
+  let depoisDeBranco = false
+  for (const linha of conteudo.replace(/\r\n/g, '\n').split('\n')) {
+    const recuo = linha.length - linha.trimStart().length
+    const rotulo = ROTULO_DE_TOUCH_PATHS.exec(linha)
+    if (rotulo) {
+      juntar(rotulo[1] as string)
+      recuoDoRotulo = recuo
+      depoisDeBranco = false
+      continue
+    }
+    if (recuoDoRotulo < 0) continue
+    if (linha.trim() === '') { depoisDeBranco = true; continue }
+    if (recuo <= recuoDoRotulo && (depoisDeBranco || ABRE_BLOCO.test(linha))) { recuoDoRotulo = -1; continue }
+    juntar(linha)
+    depoisDeBranco = false
+  }
+  return achados.size > 0 ? [...achados].sort() : null
+}
+
+/** O status da thread na secao `threads` do retrato `ork.maestro-snapshot/v1`, ou `null` quando ele nao diz. */
+export function statusNoRetrato(retrato: unknown, thread: string): string | null {
+  const itens = (retrato as { sections?: { threads?: { items?: unknown } } } | null)?.sections?.threads?.items
+  if (!Array.isArray(itens)) return null
+  const item = itens.find(i => (i as { id?: unknown } | null)?.id === thread) as { status?: unknown } | undefined
+  return typeof item?.status === 'string' ? item.status : null
+}
+
+/** O Freio age na thread? So deixa de agir com a thread fechada no retrato (D10). */
+export function threadAtiva(status: string | null): boolean {
+  return status !== 'fechada'
+}
+
+/** A carga de uma thread antes da primeira leitura. */
+export function cargaVazia(thread: string): FreioCarga {
+  return { thread, statusDaThread: null, claims: null, claimsEm: 0, maiorClaim: 0, touchPaths: null, planoLido: false, planoEm: 0, erros: [] }
+}
+
+/** As claims precisam ser relidas: nunca lidas, velhas, ou o lote mexeu nelas. */
+export function claimsVelhas(carga: FreioCarga, agora: number, loteMexeuNasClaims: boolean): boolean {
+  return carga.claims === null || loteMexeuNasClaims || !(agora - carga.claimsEm >= 0 && agora - carga.claimsEm < IDADE_DAS_CLAIMS_MS)
+}
+
+/** O plano precisa ser relido: nunca lido, velho, ou o lote o regravou. */
+export function planoVelho(carga: FreioCarga, agora: number, loteMexeuNoPlano: boolean): boolean {
+  return !carga.planoLido || loteMexeuNoPlano || !(agora - carga.planoEm >= 0 && agora - carga.planoEm < IDADE_DO_PLANO_MS)
+}

package/adapters/claude-code/mods/ork-freio/hooks/conferencia.ts

@@ -0,0 +1,309 @@
+// A conferencia pelo nucleo e a devolucao no lote seguinte (RM-059, F2, T2.3). Modulo puro: monta o argv do
+// `ork claims conferir`, le o JSON `ork.claims-conferencia/v1`, cuida da rodada, apura o resultado e escreve o
+// texto do lote e a linha de status. O Freio nunca roda o comando de uma claim: quem roda e o nucleo, no
+// sandbox do verify (D12 do plano dos mods), e quem verifica de verdade continua sendo o `ork verify`.
+import type { FreioEntrega, FreioFalha, FreioPedido, FreioRodada, FreioVigia } from '../types'
+
+export const FORMATO_DA_CONFERENCIA = 'ork.claims-conferencia/v1'
+/** O prazo total pedido ao nucleo, em segundos (o padrao do `ork claims conferir`, D6). */
+export const PRAZO_DA_CONFERENCIA_S = 180
+/** O vigia do mod: a conferencia que passar disto e encerrada e fica sem veredito (D6, D7). */
+export const VIGIA_DA_CONFERENCIA_MS = 240000
+/**
+ * Depois do vigia, quanto o laco espera o processo fechar; se ele seguir aberto, a conferencia fica indisponivel
+ * e nenhuma rodada nova abre enquanto ele nao fechar (duas conferencias nunca correm juntas).
+ */
+export const ESPERA_DO_FIM_MS = 30000
+/** O motivo de indisponivel quando o processo da rodada anterior nao fechou. */
+export const MOTIVO_PROCESSO_ABERTO = 'o processo anterior do ork claims conferir nao fechou depois do vigia'
+/** Claims por rodada; so uma rodada roda por vez (D5). */
+export const TETO_POR_RODADA = 6
+/** A pausa depois de uma conferencia indisponivel (D7). */
+export const PAUSA_SEM_CONFERENCIA_MS = 600000
+/** A pausa curta quando outra conducao segura a thread (saida 3): a rodada volta para a fila. */
+export const PAUSA_DE_CONDUCAO_MS = 60000
+/** Tetos do texto ao modelo (D8). */
+export const TETO_DE_CLAIMS_NO_TEXTO = 3
+export const TETO_DE_LINHAS_DA_SAIDA = 12
+export const TETO_DE_CARACTERES_DA_SAIDA = 1200
+export const TETO_DO_TEXTO = 6000
+/** O que o mod guarda da saida do processo: o JSON inteiro cabe com folga; do stderr, so o fim. */
+export const TETO_DA_SAIDA_LIDA = 4194304
+export const TETO_DO_ERRO_LIDO = 2000
+
+const ID_DE_CLAIM = /^C\d+$/
+const ID_DE_THREAD = /^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/
+/** A recusa do nucleo por uma claim so (retirada ou que nao existe): as outras da rodada voltam para a fila. */
+const RECUSA_POR_CLAIM = /^claims\.conferir\.(?:retirada|desconhecida): (C\d+)\b/
+/** A saida do CLI quando outra conducao segura a thread. */
+const SAIDA_DE_CONDUCAO = 3
+
+/** Uma claim como a conferencia a devolveu, so com o que o Freio entrega. */
+export type ItemConferido = {
+  id: string
+  alegacao: string
+  arquivo: string | null
+  verificado: boolean
+  motivo: string | null
+  comando: string
+  codigo: number | null
+  fim: string
+}
+
+/**
+ * A leitura de uma rodada: o resultado do nucleo; a recusa de uma claim so (retirada ou desconhecida); a thread
+ * conduzida por outro (saida 3); a conferencia indisponivel; ou o vigia do mod vencido.
+ */
+export type Leitura =
+  | { tipo: 'resultado'; itens: ItemConferido[] }
+  | { tipo: 'recusada'; id: string; motivo: string }
+  | { tipo: 'ocupada'; motivo: string }
+  | { tipo: 'indisponivel'; motivo: string }
+  | { tipo: 'prazo' }
+
+/** O argv do `ork claims conferir` de uma rodada; o comando das claims fica com o nucleo. */
+export function argvDaConferencia(thread: string, ids: readonly string[]): string[] {
+  if (!ID_DE_THREAD.test(thread)) throw new Error('ork-freio: id de thread invalido')
+  if (ids.length === 0 || ids.some(id => !ID_DE_CLAIM.test(id))) throw new Error('ork-freio: ids de claim invalidos')
+  return ['ork', 'claims', 'conferir', thread, '--claims', ids.join(','), '--prazo', String(PRAZO_DA_CONFERENCIA_S), '--json']
+}
+
+/** Junta um pedaco da saida, ate o teto; do stderr fica so o fim. */
+export function acumular(atual: string, pedaco: string, doErro: boolean): string {
+  const junto = atual + pedaco
+  if (doErro) return junto.length > TETO_DO_ERRO_LIDO ? junto.slice(-TETO_DO_ERRO_LIDO) : junto
+  return junto.length > TETO_DA_SAIDA_LIDA ? junto.slice(0, TETO_DA_SAIDA_LIDA) : junto
+}
+
+const ultimaLinha = (texto: string) => texto.trim().split('\n').filter(l => l.trim() !== '').slice(-1)[0]?.trim().slice(0, 300) ?? ''
+
+function itemDoNucleo(bruto: unknown): ItemConferido | null {
+  const i = bruto as { id?: unknown; alegacao?: unknown; arquivo?: unknown; verificado?: unknown; motivo?: unknown; execucoes?: unknown } | null
+  if (!i || typeof i.id !== 'string' || !ID_DE_CLAIM.test(i.id)) return null
+  const execucoes = Array.isArray(i.execucoes) ? i.execucoes as Array<{ comando?: unknown; ok?: unknown; code?: unknown; fim?: unknown }> : []
+  const chave = execucoes.find(x => x && x.ok === false) ?? execucoes[0]
+  return {
+    id: i.id,
+    alegacao: typeof i.alegacao === 'string' ? i.alegacao : '',
+    arquivo: typeof i.arquivo === 'string' ? i.arquivo : null,
+    verificado: i.verificado === true,
+    motivo: typeof i.motivo === 'string' ? i.motivo : null,
+    comando: typeof chave?.comando === 'string' ? chave.comando : '',
+    codigo: typeof chave?.code === 'number' ? chave.code : null,
+    fim: typeof chave?.fim === 'string' ? chave.fim : '',
+  }
+}
+
+/**
+ * A saida do `ork claims conferir --json` (D6, D7): o resultado so com o formato certo, itens em lista e saida
+ * 0 ou 1; a recusa de uma claim so (saida 2 com `claims.conferir.retirada` ou `.desconhecida`) e por claim; a
+ * saida 3 e outra conducao segurando a thread; o resto (saida 2 com `erro`, um `ork` antigo) e indisponivel.
+ */
+export function lerConferencia(stdout: string, codigo: number | null, stderr: string): Leitura {
+  let j: { formato?: unknown; itens?: unknown; erro?: unknown } | null = null
+  try { j = JSON.parse(stdout) } catch { j = null }
+  if (j && j.formato === FORMATO_DA_CONFERENCIA && Array.isArray(j.itens) && (codigo === 0 || codigo === 1)) {
+    return { tipo: 'resultado', itens: j.itens.map(itemDoNucleo).filter((i): i is ItemConferido => i !== null) }
+  }
+  const erro = j && typeof j.erro === 'string' ? j.erro.trim().slice(0, 300) : ''
+  const recusa = RECUSA_POR_CLAIM.exec(erro)
+  if (recusa) return { tipo: 'recusada', id: recusa[1] as string, motivo: erro }
+  // JSON que nao serve nao vira motivo: o fim do stderr diz mais; texto solto (um `ork` antigo) entra pelo fim.
+  const motivo = erro || ultimaLinha(stderr) || (j === null ? ultimaLinha(stdout) : '') || `saiu com codigo ${codigo ?? 'desconhecido'}`
+  if (codigo === SAIDA_DE_CONDUCAO) return { tipo: 'ocupada', motivo }
+  if (erro) return { tipo: 'indisponivel', motivo: erro }
+  return { tipo: 'indisponivel', motivo: `ork claims conferir sem resultado: ${motivo}` }
+}
+
+export function entregaVazia(): FreioEntrega {
+  return { falhas: [], semVeredito: [], recuperadas: [], indisponivel: null }
+}
+
+/** A vigia com os campos da conferencia preenchidos (a vigia gravada antes deles nasce sem eles). */
+export function comConferencia(v: FreioVigia): Required<FreioVigia> {
+  return {
+    rodada: null, entrega: entregaVazia(), emRisco: [], pausaAte: 0, indisponivel: null, avisouIndisponivel: false, foraPendentes: [],
+    avisadas: [],
+    ...v,
+  } as Required<FreioVigia>
+}
+
+/** Ha trabalho para o laco de fundo: fila com claim ou rodada aberta (a de um laco que morreu com o worker, D10). */
+export function precisaDeLaco(vigia: FreioVigia): boolean {
+  const v = comConferencia(vigia)
+  return v.fila.length > 0 || v.rodada !== null
+}
+
+const numero = (id: string) => Number(id.slice(1)) || 0
+
+/** A mesma ordem da fila do lote: a forca maior antes; na mesma forca, a claim mais nova antes. */
+function ordenar(pedidos: FreioPedido[]): FreioPedido[] {
+  return pedidos.sort((a, b) => b.forca - a.forca || numero(b.id) - numero(a.id))
+}
+
+/** Devolve pedidos a fila sem repeticao, juntando os caminhos e ficando com a forca maior. */
+function devolverAFila(fila: readonly FreioPedido[], pedidos: readonly FreioPedido[]): FreioPedido[] {
+  const porId = new Map(fila.map(p => [p.id, { ...p, caminhos: [...p.caminhos] }]))
+  for (const p of pedidos) {
+    const ja = porId.get(p.id)
+    if (!ja) { porId.set(p.id, { ...p, caminhos: [...p.caminhos] }); continue }
+    ja.forca = Math.max(ja.forca, p.forca)
+    for (const c of p.caminhos) if (!ja.caminhos.includes(c)) ja.caminhos.push(c)
+  }
+  return ordenar([...porId.values()])
+}
+
+/** Os pedidos de uma rodada, para voltarem a fila. */
+function pedidosDaRodada(rodada: FreioRodada, ids: readonly string[]): FreioPedido[] {
+  return ids.map(id => ({ id, forca: rodada.forcas?.[id] ?? 1, caminhos: [...(rodada.caminhos[id] ?? [])] }))
+}
+
+/**
+ * Abre a rodada: tira da fila ate o teto, se nao ha rodada aberta nem pausa; a rodada aberta segue como esta.
+ * Com a lista das claims ativas, a claim que saiu dela (retirada) sai da fila antes; a claim com numero acima do
+ * maior que a leitura viu (cadastrada depois dela) fica, e a recusa por claim do nucleo cobre o resto.
+ */
+export function iniciarRodada(vigia: FreioVigia, agora: number, teto = TETO_POR_RODADA,
+  ativas: { ids: readonly string[]; maior: number } | null = null): Required<FreioVigia> {
+  const v = comConferencia(vigia)
+  const fila = ativas ? v.fila.filter(p => ativas.ids.includes(p.id) || numero(p.id) > ativas.maior) : v.fila
+  if (v.rodada || fila.length === 0 || agora < v.pausaAte) return fila === v.fila ? v : { ...v, fila }
+  const escolhidos = fila.slice(0, teto)
+  const rodada: FreioRodada = {
+    ids: escolhidos.map(p => p.id),
+    caminhos: Object.fromEntries(escolhidos.map(p => [p.id, [...p.caminhos]])),
+    forcas: Object.fromEntries(escolhidos.map(p => [p.id, p.forca])),
+    inicio: v.seq,
+  }
+  return { ...v, fila: fila.slice(teto), rodada }
+}
+
+/**
+ * O resultado da claim e velho (D6): a claim voltou para a fila durante a rodada (um lote tocou qualquer caminho
+ * que a afeta: o arquivo dela, um caminho do comando ou o nome-base) ou um caminho que a abriu foi tocado depois.
+ */
+function velha(v: Required<FreioVigia>, rodada: FreioRodada, id: string): boolean {
+  return v.fila.some(p => p.id === id) || (rodada.caminhos[id] ?? []).some(c => (v.toques[c] ?? 0) > rodada.inicio)
+}
+
+/** Fecha a rodada com a leitura: quebra, sem veredito, recuperada, recusa, conducao alheia e indisponivel (D6, D7). */
+export function fecharRodada(vigia: FreioVigia, leitura: Leitura, agora: number): Required<FreioVigia> {
+  const v = comConferencia(vigia)
+  const rodada = v.rodada
+  if (!rodada) return v
+  if (leitura.tipo === 'indisponivel') {
+    return {
+      ...v, rodada: null, fila: [], pausaAte: agora + PAUSA_SEM_CONFERENCIA_MS, indisponivel: leitura.motivo,
+      entrega: v.avisouIndisponivel ? v.entrega : { ...v.entrega, indisponivel: leitura.motivo }, avisouIndisponivel: true,
+    }
+  }
+  if (leitura.tipo === 'recusada') {
+    // So a claim recusada sai; as outras voltam para a fila e rodam na proxima rodada, sem pausa e sem aviso.
+    const fila = devolverAFila(v.fila.filter(p => p.id !== leitura.id), pedidosDaRodada(rodada, rodada.ids.filter(id => id !== leitura.id)))
+    return { ...v, rodada: null, fila, emRisco: v.emRisco.filter(id => id !== leitura.id) }
+  }
+  if (leitura.tipo === 'ocupada') {
+    return { ...v, rodada: null, fila: devolverAFila(v.fila, pedidosDaRodada(rodada, rodada.ids)), pausaAte: agora + PAUSA_DE_CONDUCAO_MS }
+  }
+  const avisadas = new Set(v.avisadas)
+  const falhas = new Map(v.entrega.falhas.map(f => [f.id, f]))
+  const semVeredito = new Map(v.entrega.semVeredito.map(s => [s.id, s]))
+  const recuperadas = new Set(v.entrega.recuperadas)
+  const emRisco = new Set(v.emRisco)
+  const semVez = (id: string, motivo: string) => { semVeredito.set(id, { id, motivo }); falhas.delete(id) }
+  if (leitura.tipo === 'prazo') {
+    for (const id of rodada.ids) if (!velha(v, rodada, id)) semVez(id, 'prazo do Freio')
+  } else {
+    for (const item of leitura.itens) {
+      if (!rodada.ids.includes(item.id) || velha(v, rodada, item.id)) continue
+      if (item.verificado) {
+        // So volta como recuperada a claim cuja falha o modelo ja recebeu; a que ele nunca viu sai sem barulho.
+        falhas.delete(item.id)
+        semVeredito.delete(item.id)
+        emRisco.delete(item.id)
+        if (avisadas.delete(item.id)) recuperadas.add(item.id)
+      } else if (item.motivo === 'claims.failed') {
+        const falha: FreioFalha = { id: item.id, alegacao: item.alegacao, arquivo: item.arquivo, comando: item.comando, codigo: item.codigo, fim: item.fim }
+        falhas.set(item.id, falha)
+        semVeredito.delete(item.id)
+        recuperadas.delete(item.id)
+        emRisco.add(item.id)
+      } else semVez(item.id, item.motivo ?? 'sem motivo')
+    }
+  }
+  return {
+    ...v, rodada: null, indisponivel: null, emRisco: [...emRisco], avisadas: [...avisadas],
+    entrega: { ...v.entrega, falhas: [...falhas.values()], semVeredito: [...semVeredito.values()], recuperadas: [...recuperadas] },
+  }
+}
+
+/**
+ * A conferencia fica indisponivel sem rodada aberta (o processo da rodada anterior nao fechou): o mesmo efeito da
+ * leitura indisponivel (D7), avisando o modelo so na primeira vez.
+ */
+export function indisponivelSemRodada(vigia: FreioVigia, motivo: string, agora: number): Required<FreioVigia> {
+  const v = comConferencia(vigia)
+  return {
+    ...v, fila: [], pausaAte: agora + PAUSA_SEM_CONFERENCIA_MS, indisponivel: motivo,
+    entrega: v.avisouIndisponivel ? v.entrega : { ...v.entrega, indisponivel: motivo }, avisouIndisponivel: true,
+  }
+}
+
+/** Tira a entrega da vigia para o lote devolver: a vigia fica com a entrega vazia e lembra as falhas avisadas. */
+export function tomarEntrega(vigia: FreioVigia): { vigia: Required<FreioVigia>; entrega: FreioEntrega } {
+  const v = comConferencia(vigia)
+  const avisadas = [...new Set([...v.avisadas, ...v.entrega.falhas.map(f => f.id)])]
+  return { vigia: { ...v, entrega: entregaVazia(), avisadas }, entrega: v.entrega }
+}
+
+/** O fim da saida de uma claim: as ultimas linhas e o ultimo trecho, dentro dos tetos (D8). */
+export function fimDaSaida(fim: string): string[] {
+  let texto = fim.replace(/\s+$/, '')
+  if (texto.length > TETO_DE_CARACTERES_DA_SAIDA) texto = texto.slice(-TETO_DE_CARACTERES_DA_SAIDA)
+  return texto.split('\n').slice(-TETO_DE_LINHAS_DA_SAIDA)
+}
+
+/** O texto inteiro de um lote dentro do teto (D8), com a marca de corte. */
+export function limitarTexto(texto: string): string {
+  return texto.length > TETO_DO_TEXTO ? `${texto.slice(0, TETO_DO_TEXTO - 40)}\n(texto cortado pelo Freio de Lote)` : texto
+}
+
+const lista = (ids: readonly string[]) => ids.join(', ')
+
+/** O texto que o lote devolve ao modelo (D8); sem novidade, nenhum texto. */
+export function textoDaEntrega(e: FreioEntrega): string {
+  const partes: string[] = []
+  const n = e.falhas.length
+  if (n > 0) {
+    partes.push(`Freio de Lote: a conferencia do nucleo reprovou ${n === 1 ? '1 claim ligada' : `${n} claims ligadas`} ao que voce mexeu (ork claims conferir, no sandbox do verify, sem recibo).`)
+    for (const f of e.falhas.slice(0, TETO_DE_CLAIMS_NO_TEXTO)) {
+      partes.push(`- ${f.id}${f.arquivo ? ` (${f.arquivo})` : ''}: ${f.alegacao}`)
+      partes.push(`  comando: ${f.comando}`)
+      partes.push(`  saiu com codigo ${f.codigo ?? 'desconhecido'}; fim da saida:`)
+      for (const linha of fimDaSaida(f.fim)) partes.push(`  | ${linha}`)
+    }
+    if (n > TETO_DE_CLAIMS_NO_TEXTO) partes.push(`- e mais ${n - TETO_DE_CLAIMS_NO_TEXTO}: ${lista(e.falhas.slice(TETO_DE_CLAIMS_NO_TEXTO).map(f => f.id))}`)
+    partes.push('Rode o comando para confirmar: teste que cria processo pode reprovar no sandbox e passar no ork verify, que continua sendo quem verifica.')
+  }
+  if (e.recuperadas.length > 0) {
+    partes.push(`Freio de Lote: ${lista(e.recuperadas)} ${e.recuperadas.length === 1 ? 'voltou' : 'voltaram'} a passar na conferencia do nucleo.`)
+  }
+  if (e.semVeredito.length > 0) {
+    const motivos = [...new Set(e.semVeredito.map(s => s.motivo))]
+    partes.push(`Freio de Lote: a conferencia de ${lista(e.semVeredito.map(s => s.id))} terminou sem veredito (${motivos.join(', ')}); o ork verify decide.`)
+  }
+  if (e.indisponivel) {
+    partes.push(`Freio de Lote: a conferencia das claims esta indisponivel nesta sessao (${e.indisponivel}). O Freio segue sem conferir; o ork verify continua valendo.`)
+  }
+  return limitarTexto(partes.join('\n'))
+}
+
+/** A linha de status do Freio (D8); `undefined` limpa a linha. */
+export function textoDoStatus(vigia: FreioVigia, agora: number): string | undefined {
+  const v = comConferencia(vigia)
+  if (v.indisponivel && agora < v.pausaAte) return 'freio: conferencia indisponivel'
+  if (v.rodada) return `freio: conferindo ${lista(v.rodada.ids)}`
+  const n = v.emRisco.length
+  if (n > 0) return `freio: ${n === 1 ? '1 claim' : `${n} claims`} em risco (${lista(v.emRisco.slice(0, 5))}${n > 5 ? ', ...' : ''})`
+  return undefined
+}

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

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