@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-grafo.js

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GRAFO_EN = exports.GRAFO_PT_BR = void 0;
+/** RM-061 F3d: moldura humana do grafo; schemas, códigos e JSON continuam em pt-BR. */
+exports.GRAFO_PT_BR = {
+    uso: [
+        'uso: ork grafo indexar [--verificar] [--forcar] [--json]',
+        '     ork grafo status [--json]',
+        '     ork grafo contexto <thread> [--json [--teto-bytes N]]',
+        '     ork grafo vizinhos <no> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo chamadores <simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo importadores <arquivo|simbolo> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '     ork grafo caminho <de> <para> [--sentido saida|entrada|ambos] [--tipo T,...] [--json [--teto-bytes N]]',
+        '     ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir ARQ [--json]',
+        '     ork grafo limpar [--tudo] [--json]',
+    ],
+    erroUso: (motivo) => `grafo.uso: ${motivo}`,
+    motivos: {
+        semSub: 'falta o subcomando', desconhecido: (sub) => `subcomando desconhecido: ${sub}`,
+        repetida: (nome) => `--${nome} repetida`, semValor: (nome) => `--${nome} nao leva valor`,
+        exigeValor: (nome) => `--${nome} exige valor`, opcao: (sub, valor) => `opcao desconhecida para ${sub}: ${valor}`,
+        argumentos: (sub, esperados, recebidos) => `${sub} pede ${esperados} argumento(s), veio ${recebidos}`,
+        inteiro: (nome) => `--${nome} precisa ser inteiro`, tipo: (tipo, lista) => `--tipo desconhecido: ${tipo} (use ${lista})`,
+        sentido: (valor) => `--sentido desconhecido: ${valor}`, tetoJson: '--teto-bytes exige --json', tetoMin: '--teto-bytes precisa ser ao menos 1',
+        amostraExclusiva: '--conferir e --por-estrato nao combinam', estratoMin: '--por-estrato precisa ser ao menos 1',
+    },
+    indexar: {
+        titulo: (repo, estado) => `indice do grafo de ${repo}: ${estado}`,
+        // O rotulo ocupa 13 colunas antes do valor, como na base: 12 do nome e um espaco.
+        campo: (nome, valor) => `  ${nome.padEnd(12)} ${valor}`,
+        campos: { revisao: 'revisao', chave: 'chave', snapshot: 'snapshot', digest: 'digest', conferencia: 'conferencia',
+            nos: 'nos', arestas: 'arestas', lugar: 'lugar', motivo: 'motivo', tempo: 'tempo' },
+        conferencia: (fontes, evidencias) => `conferirFontes verificada: ${fontes} fontes e ${evidencias} evidencias contra os bytes`,
+        determinismo: (ordem, digest, relatorio, unidades, igual) => `  determinismo ${ordem}: digest ${digest}, relatorio ${relatorio}, unidades ${unidades}, ${igual ? 'igual' : 'DIFERENTE'}`,
+        incremental: (base, igual) => `  incremental  a partir do indice de ${base}: ${igual ? 'igual a completa nos quatro arquivos' : 'DIFERENTE'}`,
+        naoConferido: (motivo) => `  incremental  nao conferido: ${motivo}`, aprovado: 'aprovado', semBase: 'sem base',
+    },
+    status: {
+        titulo: (head, arvore) => `grafo: HEAD ${head}, arvore ${arvore}`,
+        indice: (chave, estado) => `  indice do HEAD  ${chave} ${estado}`,
+        ausente: '(ausente: rode ork grafo indexar)', semAnalisadores: '(sem os analisadores nesta instalacao, nem a consulta nem o indexar rodam)',
+        semChave: '(sem a chave do indice: o erro esta na linha de baixo)', analisadores: (v) => `  analisadores    ${v}`,
+        correcao: (v) => `  correcao        ${v}`, pasta: (dir, n, mb) => `  pasta           ${dir} (${n} indice(s), ${mb})`,
+        semCommit: 'sem commit', indisponivel: 'indisponivel', naoCriada: 'ainda nao criada', sobras: (v) => `  sobras          ${v}`,
+    },
+    contexto: {
+        titulo: (thread, revisao) => `Contexto ${thread} @ ${revisao}`,
+        resumo: (sementes, total, arestas, ligacoes, bytes) => `  ${sementes}/${total} sementes, ${arestas}/${ligacoes} ligacoes agregadas; ${bytes} bytes JSON`,
+        tamanho: (bytes) => `  tamanho dos arquivos no pacote (nao descoberta): ${bytes} bytes (revisao indexada); tokens: unavailable`,
+        diff: (v) => `  diff: ${v}`, mudadas: (n) => `  ligacoes com fonte modificada na arvore: ${n}`,
+        final: (truncado, arvore) => `  truncado: ${truncado}; arvore: ${arvore}; use --json para nos e evidencias`,
+    },
+    amostra: {
+        titulo: (arestas, estratos, revisao) => `amostra: ${arestas} arestas em ${estratos} estratos, auditada na revisao ${revisao}`,
+        vereditos: (v) => `  vereditos ${v}`, conferidas: (ok, total) => `  conferidas contra o indice do HEAD: ${ok} de ${total}`,
+        falha: (v) => `FALHA ${v}`, reprovado: (n) => `reprovado: ${n} falha(s)`, aprovado: 'aprovado',
+    },
+    limpar: (n, mb) => `grafo limpar: ${n} removido(s), ${mb}`,
+    consulta: {
+        titulo: (repo, revisao, chave, snapshot) => `grafo de ${repo} na revisao ${revisao}, indice ${chave}, snapshot ${snapshot}`,
+        arvore: 'aviso: a arvore tem mudanca rastreada; a resposta e do HEAD, nao da arvore',
+        fontes: (v, resto) => `fontes que mudaram na arvore: ${v}${resto ? ` e mais ${resto}` : ''}`,
+        marca: '  [fonte modificada na arvore]', pagina: (p) => `pagina ${p}`, extratores: (v) => `extratores: ${v}`,
+        semCaminho: (de, para, sentido, nos) => `sem caminho de ${de} para ${para} (sentido ${sentido}): ${nos} nos explorados`,
+        caminho: (de, para, sentido, passos) => `caminho de ${de} para ${para} (sentido ${sentido}): ${passos} passo(s)`,
+        contra: '(contra a aresta) ', todos: 'todos',
+        resultado: (tipo, alvo, profundidade, filtro, arestas, nos) => `${tipo} de ${alvo} (profundidade ${profundidade}${filtro}): ${arestas} aresta(s), ${nos} no(s)`,
+        filtro: (sentido, tipos) => `, sentido ${sentido}, tipos ${tipos}`,
+        truncado: (n, total) => `truncado: ${n} de ${total} arestas, as mais perto do alvo; use --limite`,
+        parcial: 'parcial: so arestas que o extrator prova; chamada por despacho de tipo, import nao resolvido e as lacunas do relatorio de extracao ficam fora',
+    },
+};
+exports.GRAFO_EN = {
+    uso: [
+        'usage: ork grafo indexar [--verificar] [--forcar] [--json]', '       ork grafo status [--json]',
+        '       ork grafo contexto <thread> [--json [--teto-bytes N]]',
+        '       ork grafo vizinhos <node> [--profundidade N] [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo chamadores <symbol> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo importadores <file|symbol> [--profundidade N] [--limite N] [--json [--teto-bytes N]]',
+        '       ork grafo caminho <from> <to> [--sentido saida|entrada|ambos] [--tipo T,...] [--json [--teto-bytes N]]',
+        '       ork grafo amostra [--por-estrato N] | ork grafo amostra --conferir FILE [--json]', '       ork grafo limpar [--tudo] [--json]',
+    ],
+    erroUso: (reason) => `grafo.uso: ${reason}`,
+    motivos: {
+        semSub: 'missing subcommand', desconhecido: (sub) => `unknown subcommand: ${sub}`, repetida: (name) => `--${name} repeated`,
+        semValor: (name) => `--${name} takes no value`, exigeValor: (name) => `--${name} requires a value`, opcao: (sub, value) => `unknown option for ${sub}: ${value}`,
+        argumentos: (sub, expected, received) => `${sub} expects ${expected} argument(s), received ${received}`, inteiro: (name) => `--${name} must be an integer`,
+        tipo: (type, list) => `unknown --tipo: ${type} (use ${list})`, sentido: (value) => `unknown --sentido: ${value}`,
+        tetoJson: '--teto-bytes requires --json', tetoMin: '--teto-bytes must be at least 1', amostraExclusiva: '--conferir and --por-estrato cannot be combined', estratoMin: '--por-estrato must be at least 1',
+    },
+    indexar: {
+        titulo: (repo, state) => `graph index for ${repo}: ${state}`, campo: (name, value) => `  ${name.padEnd(12)} ${value}`,
+        campos: { revisao: 'revision', chave: 'key', snapshot: 'snapshot', digest: 'digest', conferencia: 'check',
+            nos: 'nodes', arestas: 'edges', lugar: 'location', motivo: 'reason', tempo: 'time' },
+        conferencia: (sources, evidence) => `conferirFontes verified: ${sources} sources and ${evidence} evidence items against the bytes`,
+        determinismo: (order, digest, report, units, equal) => `  determinism   ${order}: digest ${digest}, report ${report}, units ${units}, ${equal ? 'equal' : 'DIFFERENT'}`,
+        incremental: (base, equal) => `  incremental  from index ${base}: ${equal ? 'equal to the full build in all four files' : 'DIFFERENT'}`,
+        naoConferido: (reason) => `  incremental  not checked: ${reason}`, aprovado: 'approved', semBase: 'no base',
+    },
+    status: {
+        titulo: (head, tree) => `graph: HEAD ${head}, tree ${tree}`, indice: (key, state) => `  HEAD index     ${key} ${state}`,
+        ausente: '(missing: run ork grafo indexar)', semAnalisadores: '(without analyzers in this installation, neither queries nor indexing can run)',
+        semChave: '(no index key: the error is on the next line)', analisadores: (v) => `  analyzers      ${v}`, correcao: (v) => `  fix            ${v}`,
+        pasta: (dir, n, mb) => `  directory      ${dir} (${n} index(es), ${mb})`, semCommit: 'no commit', indisponivel: 'unavailable', naoCriada: 'not created yet', sobras: (v) => `  leftovers      ${v}`,
+    },
+    contexto: {
+        titulo: (thread, revision) => `Context ${thread} @ ${revision}`,
+        resumo: (seeds, total, edges, links, bytes) => `  ${seeds}/${total} seeds, ${edges}/${links} aggregated links; ${bytes} JSON bytes`,
+        tamanho: (bytes) => `  file size in the package (not discovery): ${bytes} bytes (indexed revision); tokens: unavailable`,
+        diff: (v) => `  diff: ${v}`, mudadas: (n) => `  links with a modified source in the tree: ${n}`,
+        final: (truncated, tree) => `  truncated: ${truncated}; tree: ${tree}; use --json for nodes and evidence`,
+    },
+    amostra: {
+        titulo: (edges, strata, revision) => `sample: ${edges} edges in ${strata} strata, audited at revision ${revision}`,
+        vereditos: (v) => `  verdicts ${v}`, conferidas: (ok, total) => `  checked against the HEAD index: ${ok} of ${total}`,
+        falha: (v) => `FAIL ${v}`, reprovado: (n) => `failed: ${n} failure(s)`, aprovado: 'approved',
+    },
+    limpar: (n, mb) => `graph cleanup: ${n} removed, ${mb}`,
+    consulta: {
+        titulo: (repo, revision, key, snapshot) => `graph for ${repo} at revision ${revision}, index ${key}, snapshot ${snapshot}`,
+        arvore: 'warning: the tree has tracked changes; the answer is from HEAD, not the tree',
+        fontes: (v, rest) => `sources changed in the tree: ${v}${rest ? ` and ${rest} more` : ''}`, marca: '  [source modified in tree]', pagina: (p) => `page ${p}`,
+        extratores: (v) => `extractors: ${v}`, semCaminho: (from, to, direction, nodes) => `no path from ${from} to ${to} (direction ${direction}): ${nodes} nodes explored`,
+        caminho: (from, to, direction, steps) => `path from ${from} to ${to} (direction ${direction}): ${steps} step(s)`, contra: '(against the edge) ', todos: 'all',
+        resultado: (type, target, depth, filter, edges, nodes) => `${type} of ${target} (depth ${depth}${filter}): ${edges} edge(s), ${nodes} node(s)`,
+        filtro: (direction, types) => `, direction ${direction}, types ${types}`, truncado: (n, total) => `truncated: ${n} of ${total} edges, nearest to the target; use --limite`,
+        parcial: 'partial: only edges proven by the extractor; dynamic dispatch calls, unresolved imports, and extraction-report gaps are excluded',
+    },
+};

package/dist/locale-master.js

@@ -0,0 +1,182 @@
+"use strict";
+/**
+ * RM-061, fatia F2b: a familia `master` do catalogo de mensagens (`ork master`, o indice das entregas;
+ * `ork master [<thread>] --aceitar-omissao`; e `ork master pedir`). O pt-BR e a fonte; o ingles e tipado
+ * por ele. Sem import do nucleo.
+ *
+ * O MASTER log, o POSTMORTEM e o registro da omissao sao dado e nascem em pt-BR, no escopo da gravacao; o
+ * catalogo traduz o que o comando imprime em volta deles. A nota pedida pelo canal segue o formato de
+ * resposta `<codigo> <0 a 5> <porque>` nas duas linguas (o leitor do canal so olha o codigo e o numero).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MASTER_EN = exports.MASTER_PT_BR = void 0;
+const CLASSES_DE_FALHA_DO_CATALOGO = {
+    'sem-falha': 'a thread atravessou o ciclo sem incidente',
+    'erro-de-spec': 'o objetivo ou o plano estavam errados; a execucao seguiu a spec errada',
+    'base-avancou': 'a base mudou embaixo da thread e o trabalho precisou ser ressincronizado',
+    conflito: 'colisao de regiao entre threads, resolvida na mao',
+    'rate-limit': 'o runtime bateu limite de uso e a fase parou por isso',
+    modelo: 'o modelo errou (alucinou, ignorou instrucao, entregou self-report)',
+    processo: 'o metodo falhou: gate faltando, verificacao pulada, evidencia nao coletada',
+    'scope-creep': 'a entrega cresceu alem do que o GOAL prometia',
+    outra: 'nao cabe em nenhuma classe acima (descreva na justificativa)',
+};
+exports.MASTER_PT_BR = {
+    // ork master: o indice
+    semEntregaTodas: 'Nenhuma thread aberta sem score.',
+    semEntrega: 'Nenhuma entrega esperando decisao. Para ver tambem as que ainda nao entregaram: ork master --todas',
+    entregas: (n) => `Entregas (${n}) com o indice ja derivado do ledger. O numero nao foi digitado por ninguem.`,
+    colunas: ['ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'ENTREGOU', 'INDICE', 'DE ONDE VEIO'],
+    simNao: (sim) => sim ? 'sim' : 'nao',
+    semTropeco: 'sem tropeco',
+    entregueEAceito: 'ENTREGUE E ACEITO, a menos que voce diga o contrario.',
+    aceitarEsta: '  ork master <id> --aceitar-omissao     aceita so esta entrega, com o indice e os insumos no ledger',
+    aceitarTodas: '  ork master --aceitar-omissao          aceita TODAS as entregues da lista (--dry-run mostra quais, sem gravar)',
+    reclamar: '  ork master <id> --score <0-5> --justificativa "<por que>" --por <humano>   se quiser reclamar',
+    classesFixas: (classes) => `Classes fixas: ${classes}`,
+    aceitasTitulo: (n) => `Aceitas por omissao (${n}): o que passou sem voce olhar.`,
+    colunasAceitas: ['ID', 'INDICE', 'SCORE GRAVADO', 'ACEITA EM'],
+    caiuDepois: (n, threads) => `ATENCAO: ${n} entrega(s) cairam DEPOIS de aceitas: ${threads}.`,
+    caiuDepoisLinha1: '  O MASTER log e contrato congelado e nao se reescreve sozinho. Pontue para o',
+    caiuDepoisLinha2: '  registro humano alcancar o fato; o registro da omissao permanece no ledger.',
+    discordouDeAlguma: 'Discordou de alguma? A nota humana sobrescreve, e o registro da omissao permanece:',
+    pontuar: '  ork master <thread-id> --score <0-5> --justificativa "<por que>" --por <humano>',
+    // ork master --aceitar-omissao
+    usoOmissao: 'uso: ork master <thread-id> --aceitar-omissao [--dry-run] [--json]   (ou --thread <thread-id>, uma thread so)',
+    ensaio: 'Ensaio (--dry-run): nada foi gravado.',
+    nadaEsperando: 'Nenhuma entrega esperando decisao.',
+    fecharia: (n) => `Fecharia por omissao: ${n}.`,
+    linhaDoIndice: (thread, valor, base) => `  ${thread.padEnd(20)} indice ${valor}/${base}`,
+    aceitas: (n) => `Aceitas por omissao: ${n}. O indice e os insumos foram ao ledger.`,
+    discordou: 'Discordou? A nota humana sobrescreve, e o registro da omissao permanece.',
+    foraAdmin: (id, motivo) => `a thread ${id} foi fechada administrativamente (${motivo}); nao ha entrega para aceitar.`,
+    foraJaFechada: (id) => `a thread ${id} ja tem MASTER registrado; nada a aceitar.`,
+    foraSemEntrega: (id) => `a thread ${id} ainda nao entregou (sem ship_done no ledger); registre a entrega antes: ork ship registrar-pr ${id}`,
+    avisoSemThread: (marca, ensaio, n) => `aviso: master.omissao-sem-thread: processo de agente (${marca}) ` +
+        `${ensaio ? 'fecharia' : 'fechou'} ${n} threads, inclusive as de outras frentes paralelas.`,
+    avisoSoASua: (propria, ensaio) => `  Para fechar so a sua: ork master ${propria} --aceitar-omissao` +
+        (ensaio ? '' : '  (a nota humana sobrescreve o aceite de quem nao era seu)'),
+    /** A marca de host do processo, como `marcaDeHost` a nomeia. */
+    marcaDespachada: 'sessão despachada (ORK_DISPATCH_ID)',
+    // ork master pedir
+    usoPedir: 'uso: ork master pedir <thread> [--formato telegram|terminal|json]',
+    notaTitulo: (telegram, thread, nome) => `${telegram ? '🧾 ' : ''}Nota da entrega ${thread} (${nome})`,
+    notaSemNota: (telegram) => `${telegram ? '• ' : '- '}Sem nota, vale a aceita por omissão, com o índice derivado do ledger ao lado.`,
+    notaResponda: (telegram, codigo) => `${telegram ? '↩️ ' : ''}Responda: ${codigo} <0 a 5> <porquê>, por exemplo: ${codigo} 4 entregou o que pedi.`,
+    // thread-close.ts: a entrega que o MASTER exige
+    encerradaAdmin: 'thread encerrada administrativamente não pode receber MASTER',
+    exigeEntrega: 'MASTER exige entrega: ship_done ou artefato existente com hash verificado',
+    complementar: {
+        batchAposentado: 'master.fila-aposentada: a fila de ratificacao de score saiu na I-43. Entregue e aceito, a menos que voce diga o contrario.\n' +
+            '  ork master                     as entregas, com o indice ja derivado do ledger\n' +
+            '  ork master <id> --aceitar-omissao   aceita so esta entrega, com indice e insumos no ledger\n' +
+            '  ork master --aceitar-omissao        aceita todas as entregues (--dry-run mostra quais)\n' +
+            '  ork master <id> --score <0-5> --justificativa "<por que>" --por <humano>   para reclamar',
+        informeThread: 'informe a thread para propor MASTER',
+        usoScore: 'uso: ork master <thread-id> --score 0-5 --justificativa "<texto>" --por <seu-nome>',
+        scoreHumano: '  o score do MASTER e humano, de 0 a 5, e a justificativa e obrigatoria.',
+        justificativa: (id) => `Score RECUSADO para a thread ${id}: falta --justificativa "<texto>".`,
+        justificativaRazao: '  Score sem justificativa nao vira aprendizado; o `ork` nao o registra.',
+        justificativaComando: (id, score) => `  ork master ${id} --score ${score} --justificativa "<por que este score>"`,
+        classeInvalida: (classe) => `classe de falha invalida: "${classe}".`,
+        classesFixas: (classes) => `  classes fixas: ${classes}`,
+        proposta: (chave, threads, dias) => `Proposta de policy: ${chave} em ${threads} threads nos ultimos ${dias} dias.`,
+        soProposta: '  So proposta: vira policy quando voce a declara em policies: no orkastery.yaml (ork licoes).',
+        proximo: 'Proximo passo: ork board --all   |   entregas e indice: ork master',
+        registrado: (id) => `MASTER registrado: thread ${id} fechada.`,
+        score: (valor, regime) => `  score          ${valor}/5 (${regime})`,
+        justificativaLinha: (valor) => `  justificativa  ${valor}`,
+        avaliado: (por, em) => `  avaliado por   ${por} em ${em}`,
+        classes: (valor) => `  classes        ${valor}`,
+        fases: (valor) => `  fases          ${valor}`,
+        entregas: (n) => `  entregas       ${n} ship(s) concluido(s) no ledger`,
+        gates: (n) => `  gates          ${n} reprovacao(oes) tipada(s)`,
+        postmortem: (arquivo) => `  POSTMORTEM     ${arquivo}`,
+        log: (arquivo, contrato) => `  MASTER log     ${arquivo} (contrato ${contrato})`,
+        aviso: (valor) => `  AVISO: ${valor}`,
+        classesTitulo: 'Classes de falha do POSTMORTEM (fixas, nao extensiveis pelo executor)',
+        descricoes: CLASSES_DE_FALHA_DO_CATALOGO,
+    },
+};
+exports.MASTER_EN = {
+    semEntregaTodas: 'No open thread without a score.',
+    semEntrega: 'No delivery waiting for a decision. To also see the ones that have not shipped yet: `ork master --todas`',
+    entregas: (n) => `Deliveries (${n}), with the index already derived from the ledger. Nobody typed the number.`,
+    colunas: ['ID', 'SLUG', 'MODE', 'PHASE', 'STATUS', 'SHIPPED', 'INDEX', 'WHERE IT CAME FROM'],
+    simNao: (sim) => sim ? 'yes' : 'no',
+    semTropeco: 'no setbacks',
+    entregueEAceito: 'SHIPPED AND ACCEPTED, unless you say otherwise.',
+    aceitarEsta: '  ork master <id> --aceitar-omissao     accepts only this delivery, with the index and its inputs in the ledger',
+    aceitarTodas: '  ork master --aceitar-omissao          accepts ALL shipped deliveries in the list (`--dry-run` shows which, without writing)',
+    reclamar: '  ork master <id> --score <0-5> --justificativa "<why>" --por <human>   if you want to dispute it',
+    classesFixas: (classes) => `Fixed classes: ${classes}`,
+    aceitasTitulo: (n) => `Accepted by default (${n}): what went through without you looking.`,
+    colunasAceitas: ['ID', 'INDEX', 'RECORDED SCORE', 'ACCEPTED AT'],
+    caiuDepois: (n, threads) => `WARNING: ${n} delivery(ies) dropped AFTER being accepted: ${threads}.`,
+    caiuDepoisLinha1: '  The MASTER log is a frozen contract and does not rewrite itself. Score it so the',
+    caiuDepoisLinha2: '  human record reaches the fact; the record of the default acceptance stays in the ledger.',
+    discordouDeAlguma: 'Disagree with any? A human score overrides it, and the record of the default acceptance stays:',
+    pontuar: '  ork master <thread-id> --score <0-5> --justificativa "<why>" --por <human>',
+    usoOmissao: 'usage: ork master <thread-id> --aceitar-omissao [--dry-run] [--json]   (or --thread <thread-id>, a single thread)',
+    ensaio: 'Dry run (--dry-run): nothing was written.',
+    nadaEsperando: 'No delivery waiting for a decision.',
+    fecharia: (n) => `Would close by default: ${n}.`,
+    linhaDoIndice: (thread, valor, base) => `  ${thread.padEnd(20)} index ${valor}/${base}`,
+    aceitas: (n) => `Accepted by default: ${n}. The index and its inputs went to the ledger.`,
+    discordou: 'Disagree? A human score overrides it, and the record of the default acceptance stays.',
+    foraAdmin: (id, motivo) => `thread ${id} was closed administratively (${motivo}); there is no delivery to accept.`,
+    foraJaFechada: (id) => `thread ${id} already has a MASTER recorded; nothing to accept.`,
+    foraSemEntrega: (id) => `thread ${id} has not shipped yet (no ship_done in the ledger); record the delivery first: ork ship registrar-pr ${id}`,
+    avisoSemThread: (marca, ensaio, n) => `warning: master.omissao-sem-thread: an agent process (${marca}) ` +
+        `${ensaio ? 'would close' : 'closed'} ${n} threads, including those of other parallel workstreams.`,
+    avisoSoASua: (propria, ensaio) => `  To close only yours: ork master ${propria} --aceitar-omissao` +
+        (ensaio ? '' : '  (a human score overrides the acceptance of what was not yours)'),
+    marcaDespachada: 'dispatched session (ORK_DISPATCH_ID)',
+    usoPedir: 'usage: ork master pedir <thread> [--formato telegram|terminal|json]',
+    notaTitulo: (telegram, thread, nome) => `${telegram ? '🧾 ' : ''}Score for delivery ${thread} (${nome})`,
+    notaSemNota: (telegram) => `${telegram ? '• ' : '- '}With no score, the default acceptance stands, with the index derived from the ledger next to it.`,
+    notaResponda: (telegram, codigo) => `${telegram ? '↩️ ' : ''}Reply: ${codigo} <0 to 5> <why>, for example: ${codigo} 4 delivered what I asked for.`,
+    encerradaAdmin: 'a thread closed administratively cannot receive a MASTER',
+    exigeEntrega: 'MASTER needs a delivery: ship_done or an existing artifact with a verified hash',
+    complementar: {
+        batchAposentado: 'master.fila-aposentada: the score ratification queue was retired in I-43. Shipped and accepted, unless you say otherwise.\n' +
+            '  ork master                     deliveries, with the index already derived from the ledger\n' +
+            '  ork master <id> --aceitar-omissao   accepts only this delivery, with the index and inputs in the ledger\n' +
+            '  ork master --aceitar-omissao        accepts every shipped delivery (`--dry-run` shows which)\n' +
+            '  ork master <id> --score <0-5> --justificativa "<why>" --por <human>   to dispute it',
+        informeThread: 'provide the thread for the MASTER proposal',
+        usoScore: 'usage: ork master <thread-id> --score 0-5 --justificativa "<text>" --por <your-name>',
+        scoreHumano: '  the MASTER score is human, from 0 to 5, and the justification is required.',
+        justificativa: (id) => `Score REJECTED for thread ${id}: missing --justificativa "<text>".`,
+        justificativaRazao: '  A score without justification does not become learning; `ork` does not record it.',
+        justificativaComando: (id, score) => `  ork master ${id} --score ${score} --justificativa "<why this score>"`,
+        classeInvalida: (failureClass) => `invalid failure class: "${failureClass}".`,
+        classesFixas: (classes) => `  fixed classes: ${classes}`,
+        proposta: (key, threads, days) => `Policy proposal: ${key} in ${threads} threads over the last ${days} days.`,
+        soProposta: '  Proposal only: it becomes policy when you declare it under policies: in orkastery.yaml (`ork licoes`).',
+        proximo: 'Next step: ork board --all   |   deliveries and index: ork master',
+        registrado: (id) => `MASTER recorded: thread ${id} closed.`,
+        score: (value, regime) => `  score          ${value}/5 (${regime})`,
+        justificativaLinha: (value) => `  justification  ${value}`,
+        avaliado: (by, at) => `  evaluated by   ${by} at ${at}`,
+        classes: (value) => `  classes        ${value}`,
+        fases: (value) => `  phases         ${value}`,
+        entregas: (n) => `  deliveries     ${n} completed ship(s) in the ledger`,
+        gates: (n) => `  gates          ${n} typed failure(s)`,
+        postmortem: (file) => `  POSTMORTEM     ${file}`,
+        log: (file, contract) => `  MASTER log     ${file} (contract ${contract})`,
+        aviso: (value) => `  WARNING: ${value}`,
+        classesTitulo: 'POSTMORTEM failure classes (fixed, not extensible by the executor)',
+        descricoes: {
+            'sem-falha': 'the thread crossed the cycle without an incident',
+            'erro-de-spec': 'the goal or plan was wrong; execution followed the wrong spec',
+            'base-avancou': 'the base changed under the thread and the work had to be resynchronized',
+            conflito: 'region collision between threads, resolved manually',
+            'rate-limit': 'the runtime hit a usage limit and the phase stopped because of it',
+            modelo: 'the model failed (hallucinated, ignored an instruction, or delivered self-report)',
+            processo: 'the method failed: missing gate, skipped verification, or uncollected evidence',
+            'scope-creep': 'the delivery grew beyond what GOAL promised',
+            outra: 'it does not fit any class above (describe it in the justification)',
+        },
+    },
+};