@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-roadmap.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * RM-061, fatia F2b: a familia `roadmap` do catalogo de mensagens (`ork roadmap status` em texto; o `--json`
+ * nao muda). O pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * Sai como veio: o titulo e o que esta em aberto de cada item (dado do `docs/roadmap`), a pergunta que espera
+ * o dono (dado do pedido HITL), o estado e o proximo passo da entrega (familia de entregas, G5) e o bloco
+ * `Projeto consultado:` / `Não lido:` do RM-052, que os hosts leem e fica igual nas duas linguas (D14 da F2a).
+ * O titulo do grupo e dado do contrato e so se traduz na impressao, pelo id. Data em ingles em ISO (D2 da RM-061).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ROADMAP_EN = exports.ROADMAP_PT_BR = void 0;
+exports.ROADMAP_PT_BR = {
+    titulo: (projeto, p) => `Roadmap do ${projeto} (${p.dia}/${p.mes}, ${p.hora}:${p.minuto})`,
+    /** O titulo de cada grupo pelo id (o `--json` guarda o titulo pt-BR). */
+    grupos: { concluidos: 'Concluídos', disponiveis: 'Disponíveis com algo em aberto', hoje: 'Entregue hoje', piloto: 'Piloto',
+        desenvolvimento: 'Em desenvolvimento', refinamento: 'Refinamento', proposto: 'Proposto', descontinuado: 'Descontinuado' },
+    eMais: (n) => `• e mais ${n}`,
+    precisaDeVoce: 'O que precisa de você',
+    responda: (codigo, letra) => ` Responda ${codigo} ${letra} (ou outra letra).`,
+    chegaNoResumo: ' A pergunta chega no próximo resumo.',
+    nadaAgora: '• Nada agora.',
+    foraDoRoadmap: (n) => `• Fora do roadmap: ${n} thread(s) esperam você (ork pulse).`,
+    hitlDeConducao: (abertas, mediana) => `• HITL de condução: ${abertas} aberta(s); ${mediana}.`,
+    emSeguida: 'O que eu faço em seguida',
+    nadaEmAndamento: '• Nada em andamento; sigo o que você priorizar.',
+    prLido: (hora) => ` (PR lido às ${hora})`,
+    sigoComEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: sigo ${thread} na fase ${fase}${maquina}; ${estado}${leitura}.`,
+    comEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: ${thread} na fase ${fase}${maquina}, ${estado}${leitura}.`,
+    sigo: (item, thread, fase, maquina) => `• ${item}: sigo ${thread} na fase ${fase}${maquina}.`,
+    /** RM-063 (F2): a thread sem sessao viva verificada no runtime: desde quando e por que (o estado da entrega, quando ha). */
+    parada: (item, thread, maquina, desde, motivo, estado) => `• ${item}: ${thread}${maquina} parada${desde ? ` desde ${desde}` : ''}: ${motivo}${estado ? `; ${estado}` : ''}.`,
+    semSessaoVerificada: (item, thread, fase, maquina) => `• ${item}: ${thread} na fase ${fase}${maquina}, sem sessão verificada no runtime.`,
+    /** RM-063 (F2): a fila do `ork pulse` no fecho. */
+    filaNaoLida: (detalhe) => `• Fila do pulse não lida inteira${detalhe ? ` (${detalhe})` : ''}: confira com ork pulse.`,
+    responder: (comando) => ` Responder: ${comando}`,
+    sessaoSemThread: (id) => `sessão ${id}`,
+    /** RM-063 (F2): por que a thread parou, pelo tipo; o detalhe e dado (o ledger, o runtime). */
+    motivoDaParada: {
+        nenhumaSessao: (fase) => `nenhuma sessão despachada na fase ${fase}`,
+        despachoFalhou: (fase, detalhe) => `despacho${fase ? ` de ${fase}` : ''} falhou (${detalhe})`,
+        sessaoCaiu: (sessao, motivo) => `sessão ${sessao} caiu (${motivo})`,
+        runtimeSemResposta: (runtime, detalhe, sessao) => `runtime ${runtime} sem resposta${detalhe ? ` (${detalhe})` : ''}; a sessão ${sessao} não foi verificada`,
+        naoAparece: (sessao) => `sessão ${sessao} não aparece no runtime`,
+        fantasma: (sessao) => `sessão ${sessao} sem processo (fantasma)`,
+        encerrada: (sessao, estado) => `sessão ${sessao} encerrada (${estado})`,
+        naoLida: (detalhe) => `vida da sessão não lida (${detalhe})`,
+        semAtividade: (sessao, minutos) => `sessão ${sessao} sem atividade no rollout há ${minutos} min`,
+        retratoVelho: (minutos) => `retrato da máquina sem atualização há ${minutos} min; a sessão não foi reverificada`,
+    },
+    fabricaNaoLida: (motivo) => `Fábrica: não lido (${motivo}).`,
+    fabricaSemCopia: (branch) => `esta máquina não tem cópia local de ${branch}`,
+    fabricaClone: (branch) => `clone parcial: a cópia local de ${branch} não é lida sem rede`,
+    fabricaIlegivel: (branch) => `a cópia local de ${branch} está ilegível`,
+    fabricaVelha: (branch, ultimo) => `Fábrica: a cópia local de ${branch} está velha (${ultimo
+        ? `esta máquina publicou nela por último em ${ultimo}` : 'esta máquina não aparece nela'}); não dá para dizer quem está sem batida.`,
+    semBatida: (maquina, idade, retrato) => `${maquina} sem batida há ${idade} (último retrato ${retrato})`,
+    fabricaSemBatida: (maquinas, branch) => `Fábrica: ${maquinas}, pela cópia local de ${branch}.`,
+};
+exports.ROADMAP_EN = {
+    titulo: (projeto, p) => `${projeto} roadmap (${p.ano}-${p.mes}-${p.dia} ${p.hora}:${p.minuto})`,
+    grupos: { concluidos: 'Done', disponiveis: 'Available with something open', hoje: 'Shipped today', piloto: 'Pilot',
+        desenvolvimento: 'In development', refinamento: 'Refinement', proposto: 'Proposed', descontinuado: 'Discontinued' },
+    eMais: (n) => `• and ${n} more`,
+    precisaDeVoce: 'What needs you',
+    responda: (codigo, letra) => ` Reply ${codigo} ${letra} (or another letter).`,
+    chegaNoResumo: ' The question comes in the next summary.',
+    nadaAgora: '• Nothing right now.',
+    foraDoRoadmap: (n) => `• Outside the roadmap: ${n} thread(s) waiting for you (\`ork pulse\`).`,
+    hitlDeConducao: (abertas, mediana) => `• Conduction HITL: ${abertas} open; ${mediana}.`,
+    emSeguida: 'What I do next',
+    nadaEmAndamento: '• Nothing in progress; next is whatever you prioritize.',
+    prLido: (hora) => ` (PR read at ${hora})`,
+    sigoComEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: I continue with ${thread} in phase ${fase}${maquina}; ${estado}${leitura}.`,
+    comEstado: (item, thread, fase, maquina, estado, leitura) => `• ${item}: ${thread} in phase ${fase}${maquina}, ${estado}${leitura}.`,
+    sigo: (item, thread, fase, maquina) => `• ${item}: I continue with ${thread} in phase ${fase}${maquina}.`,
+    parada: (item, thread, maquina, desde, motivo, estado) => `• ${item}: ${thread}${maquina} stopped${desde ? ` since ${desde}` : ''}: ${motivo}${estado ? `; ${estado}` : ''}.`,
+    semSessaoVerificada: (item, thread, fase, maquina) => `• ${item}: ${thread} in phase ${fase}${maquina}, no session verified in the runtime.`,
+    filaNaoLida: (detalhe) => `• Pulse queue not fully read${detalhe ? ` (${detalhe})` : ''}: check \`ork pulse\`.`,
+    responder: (comando) => ` Reply: ${comando}`,
+    sessaoSemThread: (id) => `session ${id}`,
+    motivoDaParada: {
+        nenhumaSessao: (fase) => `no session dispatched in phase ${fase}`,
+        despachoFalhou: (fase, detalhe) => `dispatch${fase ? ` of ${fase}` : ''} failed (${detalhe})`,
+        sessaoCaiu: (sessao, motivo) => `session ${sessao} went down (${motivo})`,
+        runtimeSemResposta: (runtime, detalhe, sessao) => `runtime ${runtime} not responding${detalhe ? ` (${detalhe})` : ''}; session ${sessao} was not verified`,
+        naoAparece: (sessao) => `session ${sessao} does not appear in the runtime`,
+        fantasma: (sessao) => `session ${sessao} with no process (ghost)`,
+        encerrada: (sessao, estado) => `session ${sessao} ended (${estado})`,
+        naoLida: (detalhe) => `session liveness not read (${detalhe})`,
+        semAtividade: (sessao, minutos) => `session ${sessao} with no rollout activity for ${minutos} min`,
+        retratoVelho: (minutos) => `machine snapshot not updated for ${minutos} min; the session was not re-verified`,
+    },
+    fabricaNaoLida: (motivo) => `Factory: not read (${motivo}).`,
+    fabricaSemCopia: (branch) => `this machine has no local copy of ${branch}`,
+    fabricaClone: (branch) => `partial clone: the local copy of ${branch} is not read without network`,
+    fabricaIlegivel: (branch) => `the local copy of ${branch} is unreadable`,
+    fabricaVelha: (branch, ultimo) => `Factory: the local copy of ${branch} is stale (${ultimo
+        ? `this machine last published to it at ${ultimo}` : 'this machine does not appear in it'}); there is no telling which machine has no heartbeat.`,
+    semBatida: (maquina, idade, retrato) => `${maquina} with no heartbeat for ${idade} (last snapshot ${retrato})`,
+    fabricaSemBatida: (maquinas, branch) => `Factory: ${maquinas}, from the local copy of ${branch}.`,
+};

package/dist/locale-security-scan.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * The `securityScan` family of the message catalog: `ork security-scan` output (stdout summary, `report.md`) and its
+ * usage error. pt-BR is the source; English is typed by it. No import from the core. Values that are data (tool names,
+ * states, reasons, rule ids, paths) are printed as recorded, in both languages.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SECURITY_SCAN_EN = exports.SECURITY_SCAN_PT_BR = void 0;
+exports.SECURITY_SCAN_PT_BR = {
+    usage: 'uso: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
+    // RM-072 (D9): o modo da varredura aceita so os dois valores.
+    checkInvalido: (valor) => `--check inválido: ${valor === null ? '(sem valor)' : JSON.stringify(valor)} (aceitos: classic, agile)`,
+    unknownFlag: (flag) => `opção desconhecida: ${flag}`,
+    // report.md
+    title: 'Varredura de segurança',
+    headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(não resolvida)'}\``,
+    generatedAt: (iso) => `Gerado em ${iso}`,
+    stacks: (list) => `Stacks: ${list}`,
+    noStacks: 'nenhuma detectada',
+    executionHeading: 'Execução',
+    tableTool: 'Ferramenta',
+    tableExecutor: 'Executado por',
+    tableState: 'Estado',
+    tableReason: 'Motivo',
+    noExecutor: 'nenhum',
+    states: { ran: 'executou', failed: 'falhou', unavailable: 'indisponível' },
+    noTools: 'Nenhuma ferramenta se aplica às stacks detectadas.',
+    countsHeading: 'Contagem',
+    counts: (n, existing, dismissed, loop) => `${n} novo(s), ${existing} existente(s), ${dismissed} dispensado(s); ${loop} no laço`,
+    newLoopHeading: 'Novos que entram no laço',
+    newWarnHeading: 'Novos em aviso',
+    none: 'nenhum',
+    existingTotal: (n) => `Existentes na base: ${n}`,
+    dismissedTotal: (n) => `Dispensados: ${n}`,
+    excludedHeading: 'Caminhos excluídos',
+    // stdout
+    summary: (n, existing, dismissed, loop) => `security-scan: ${n} novo(s), ${existing} existente(s), ${dismissed} dispensado(s); ${loop} no laço`,
+    notRun: (tool, state, reason) => `  ${tool}: ${state}${reason ? ` (${reason})` : ''}`,
+    notRunHeading: 'Ferramentas que não rodaram por completo:',
+};
+exports.SECURITY_SCAN_EN = {
+    usage: 'usage: ork security-scan [--base <ref>] [--json] [--check classic|agile]',
+    checkInvalido: (valor) => `invalid --check: ${valor === null ? '(no value)' : JSON.stringify(valor)} (accepted: classic, agile)`,
+    unknownFlag: (flag) => `unknown option: ${flag}`,
+    title: 'Security scan',
+    headBase: (head, base) => `HEAD \`${head.slice(0, 12)}\`, base \`${base ? base.slice(0, 12) : '(unresolved)'}\``,
+    generatedAt: (iso) => `Generated at ${iso}`,
+    stacks: (list) => `Stacks: ${list}`,
+    noStacks: 'none detected',
+    executionHeading: 'Execution',
+    tableTool: 'Tool',
+    tableExecutor: 'Executor',
+    tableState: 'State',
+    tableReason: 'Reason',
+    noExecutor: 'none',
+    states: { ran: 'ran', failed: 'failed', unavailable: 'unavailable' },
+    noTools: 'No tool applies to the detected stacks.',
+    countsHeading: 'Counts',
+    counts: (n, existing, dismissed, loop) => `${n} new, ${existing} existing, ${dismissed} dismissed; ${loop} in the loop`,
+    newLoopHeading: 'New findings that enter the loop',
+    newWarnHeading: 'New findings (warning)',
+    none: 'none',
+    existingTotal: (n) => `Existing on the base: ${n}`,
+    dismissedTotal: (n) => `Dismissed: ${n}`,
+    excludedHeading: 'Excluded paths',
+    summary: (n, existing, dismissed, loop) => `security-scan: ${n} new, ${existing} existing, ${dismissed} dismissed; ${loop} in the loop`,
+    notRun: (tool, state, reason) => `  ${tool}: ${state}${reason ? ` (${reason})` : ''}`,
+    notRunHeading: 'Tools that did not run to completion:',
+};

package/dist/locale-setup.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SETUP_EN = exports.SETUP_PT_BR = void 0;
+/** RM-061 F3d: mensagens completas de `ork setup`, sem importar o núcleo. */
+exports.SETUP_PT_BR = {
+    objeto: (campo) => `${campo} deve ser objeto`,
+    camposExatos: (campo, campos) => `${campo} deve conter somente ${campos}`,
+    fallbackInvalido: (item) => `fallback invalido: "${item}" (use runtime:modelo[:esforco], por exemplo codex:gpt-5.5)`,
+    fallbackDesconhecido: (runtime, homologados) => `fallback com runtime desconhecido: "${runtime}" (homologados: ${homologados})`,
+    fallbackRepetido: (runtime) => `fallback repete o runtime ${runtime} (o runtime do bloco e cada fallback aparecem uma vez)`,
+    limiteInvalido: (campo, positivo) => `limites.${campo} deve ser inteiro ${positivo ? 'positivo' : 'nao negativo'}, finito e representavel`,
+    blocoComLimites: 'bloco com limites exige runtime conhecido, model e effort explicitos validos',
+    contratoIncompativel: 'contrato de setup incompativel',
+    blocosArray: (modo) => `blocos de ${modo} devem ser array`,
+    limitesConhecidos: 'limites exigem contrato e bloco de modo conhecidos',
+    setupInvalido: (caminho, erro) => `setup invalido (${caminho}): ${erro}`,
+    versionadoExiste: (nome) => `setup.versionado: ${nome} ja existe neste checkout; edite com ork setup <modo> --bloco N`,
+    playbookModo: 'playbook ativo exige modo permitido valido',
+    playbookBlocos: (modo) => `playbook ativo exige todos os blocos de ${modo}`,
+    faseFora: (fase, modo) => `fase ${fase} fora do modo ${modo}`,
+    instante: (campo) => `${campo} deve ser instante inteiro nao negativo e representavel`,
+    identidadeTexto: (campo) => `identidade.${campo} deve ser texto nao vazio`,
+    identidadeModo: 'identidade de modo/bloco invalida',
+    identidadeFase: 'identidade do bloco diverge da fase selecionada',
+    herancaAmplia: (campo) => `heranca nao pode ampliar limites.${campo}`,
+    prazoVersao: 'versao de prazo incompativel',
+    identidadeDivergente: 'identidade da execucao divergente',
+    prazoInconsistente: 'origem/deadline do prazo inconsistente',
+    relogioRegressivo: 'relogio regressivo no prazo',
+    esperaComProcesso: 'espera exige ausencia comprovada de processos ativos',
+    atividadeDesconhecida: 'atividade de prazo desconhecida',
+    prazoExpirado: 'prazo expirado: heranca recusada',
+    prazoReduzido: 'prazo reduzido ja expirado',
+    blocoInexistente: (bloco, tag, total) => `bloco ${bloco} nao existe no modo ${tag}: ele tem ${total} bloco(s)`,
+    runtimeDesconhecido: (runtime, homologados) => `runtime desconhecido: "${runtime}" (homologados: ${homologados})`,
+    modeloComRuntime: 'setup.model.required: para mudar o runtime do bloco, informe --runtime e --model juntos; nenhuma configuracao foi gravada.',
+    modeloPendente: 'setup.model.required: modelo pendente neste bloco; informe --model antes de salvar.',
+    origem: {
+        versionado: (nome, local) => `Setup versionado em ${nome}: vale para todas as maquinas e muda por PR.` +
+            (local ? ' O .orkastery/setup.json local desta maquina fica ignorado.' : ''),
+        local: 'Setup local desta maquina (.orkastery/setup.json). Para valer em todas: ork setup versionar.',
+        padrao: 'Nenhum setup gravado: vale o default. Para valer em todas as maquinas: ork setup versionar.',
+    },
+    tabela: {
+        titulo: (tag, blocos, pausas) => `Setup do modo ${tag} (${blocos} bloco(s), ${pausas} pausa(s))`,
+        cabecalho: ['BLOCO', 'FASES', 'RUNTIME', 'MODEL', 'EFFORT', 'FALLBACK', 'ORIGEM'],
+        modeloPendente: '(modelo pendente)', default: 'default', customizado: 'customizado',
+        editar: (modo) => `Editar:  ork setup ${modo} --bloco N --runtime R --model M --effort E`,
+        fallback: (modo) => `Fallback: ork setup ${modo} --bloco N --fallback runtime:modelo[:esforco],...   (--fallback "" remove)`,
+        resetar: (modo, padrao) => `Resetar: ork setup ${modo} --reset   (volta para ${padrao})`,
+        runtimes: (lista) => `Runtimes homologados: ${lista}`,
+    },
+    entrevista: {
+        titulo: 'Entrevista #setup: runtime + modelo + esforco por bloco de cada modo',
+        ordem: (tags) => `Ordem das perguntas: ${tags}.`,
+        termina1: 'A entrevista termina quando todos os modos forem cobertos OU quando o owner',
+        termina2: 'disser que concluiu: o que nao for respondido fica no default.',
+        default: (padrao, excecoes) => `Default pos-instalacao: ${padrao} em todos os blocos${excecoes}`,
+        excecoes: (itens) => `, menos ${itens}.`,
+        customizado: '  <- customizado',
+        modeloPendente: '(modelo pendente)',
+        bloco: (n, fases, config, marca) => `  bloco ${n}: ${fases}  [${config}]${marca}`,
+        ver: 'Ver um modo:  ork setup <modo>',
+        editar: 'Editar bloco: ork setup <modo> --bloco N --runtime R --model M --effort E',
+        resetar: 'Resetar tudo: ork setup --reset',
+    },
+    cli: {
+        versionado: (caminho) => `Setup versionado em ${caminho}.`,
+        levePorPr: '  Leve para o repositorio por PR: dali em diante ele vale em todas as maquinas, e ork setup <modo> --bloco N passa a editar este arquivo.',
+        worktreeConfirmada: (dir, raiz) => `Pasta das worktrees "${dir}" confirmada nesta maquina para ${raiz}.`,
+        worktreeGravada: (arquivo) => `  Gravada em .orkastery/private/${arquivo} (local, fora do git). Para desfazer: ork setup worktree revogar.`,
+        worktreeRevogada: 'Confirmacao local da pasta das worktrees revogada.',
+        worktreeNaoHavia: 'Nao havia confirmacao local da pasta das worktrees.',
+        worktreeSubcomando: (acao) => `subcomando desconhecido: setup worktree ${acao} (use confirmar [<dir>] ou revogar)`,
+        worktreeManifesto: (valor, dir, dentro) => `worktree.dir no orkastery.yaml: ${valor} (${dir}, ${dentro ? 'dentro' : 'fora'} da raiz)`,
+        confirmacaoLocal: (valor) => `confirmacao local desta maquina: ${valor}`,
+        nenhumaConfirmacao: (motivo) => `nenhuma (${motivo})`,
+        criacaoPermitida: 'criacao de worktree: permitida',
+        criacaoRecusada: (comando) => `criacao de worktree: recusada. ${comando}`,
+        sandboxUso: 'uso: ork setup sandbox confirmar <read-only|workspace-write|danger-full-access> [--por Q]',
+        sandboxConfirmada: (postura, raiz) => `Postura de sandbox "${postura}" confirmada nesta maquina para ${raiz}.`,
+        sandboxGravada: (caminho) => `  Gravada em ${caminho} (local, fora do git). Para desfazer: ork setup sandbox revogar.`,
+        sandboxRevogada: 'Confirmacao local da postura de sandbox revogada.',
+        sandboxNaoHavia: 'Nao havia confirmacao local de postura de sandbox.',
+        sandboxSubcomando: (acao) => `subcomando desconhecido: setup sandbox ${acao} (use confirmar <postura> ou revogar)`,
+        sandboxManifesto: (postura) => `runtime.sandbox no orkastery.yaml: ${postura}`,
+        despachoPermitido: 'despacho pelo codex: permitido',
+        despachoRecusado: (comando) => `despacho pelo codex: recusado. ${comando}`,
+        resetado: 'Setup resetado: todos os blocos de todos os modos voltaram ao default.',
+        modoDesconhecido: (modo, aceitos) => `modo de conducao desconhecido: "${modo}" (aceitos: ${aceitos})`,
+        modoResetado: (tag) => `Setup do modo ${tag} resetado para o default.`,
+        informeBloco: 'para editar, informe o bloco: ork setup <modo> --bloco N [--runtime R] [--model M] [--effort E] [--fallback R:M,...]',
+        nadaParaEditar: 'nada para editar: informe --runtime, --model, --effort e/ou --fallback junto de --bloco',
+        edicaoRecusada: (erro) => `edicao recusada: ${erro}`,
+        blocoAlterado: (bloco, tag, de, para) => `Bloco ${bloco} do modo ${tag}: ${de} -> ${para}`,
+        gravado: (caminho) => `  gravado em ${caminho}; evento setup_configured no ledger do projeto`,
+    },
+};
+exports.SETUP_EN = {
+    objeto: (field) => `${field} must be an object`,
+    camposExatos: (field, fields) => `${field} must contain only ${fields}`,
+    fallbackInvalido: (item) => `invalid fallback: "${item}" (use runtime:model[:effort], for example codex:gpt-5.5)`,
+    fallbackDesconhecido: (runtime, allowed) => `fallback uses unknown runtime: "${runtime}" (supported: ${allowed})`,
+    fallbackRepetido: (runtime) => `fallback repeats runtime ${runtime} (the block runtime and each fallback may appear only once)`,
+    limiteInvalido: (field, positive) => `limites.${field} must be a ${positive ? 'positive' : 'non-negative'} finite representable integer`,
+    blocoComLimites: 'a block with limits requires a known runtime and explicit valid model and effort',
+    contratoIncompativel: 'incompatible setup contract',
+    blocosArray: (mode) => `${mode} blocks must be an array`,
+    limitesConhecidos: 'limits require a known contract, mode, and block',
+    setupInvalido: (path, error) => `invalid setup (${path}): ${error}`,
+    versionadoExiste: (name) => `setup.versionado: ${name} already exists in this checkout; edit it with ork setup <mode> --bloco N`,
+    playbookModo: 'an active playbook requires a valid allowed mode',
+    playbookBlocos: (mode) => `an active playbook requires every block of ${mode}`,
+    faseFora: (phase, mode) => `phase ${phase} is outside mode ${mode}`,
+    instante: (field) => `${field} must be a non-negative representable integer timestamp`,
+    identidadeTexto: (field) => `identidade.${field} must be non-empty text`,
+    identidadeModo: 'invalid mode/block identity',
+    identidadeFase: 'block identity does not match the selected phase',
+    herancaAmplia: (field) => `inheritance cannot increase limites.${field}`,
+    prazoVersao: 'incompatible deadline version',
+    identidadeDivergente: 'execution identity mismatch',
+    prazoInconsistente: 'inconsistent deadline origin or value',
+    relogioRegressivo: 'deadline clock moved backwards',
+    esperaComProcesso: 'waiting requires proven absence of active processes',
+    atividadeDesconhecida: 'unknown deadline activity',
+    prazoExpirado: 'deadline expired: inheritance refused',
+    prazoReduzido: 'shortened deadline has already expired',
+    blocoInexistente: (block, tag, total) => `block ${block} does not exist in mode ${tag}: it has ${total} block(s)`,
+    runtimeDesconhecido: (runtime, allowed) => `unknown runtime: "${runtime}" (supported: ${allowed})`,
+    modeloComRuntime: 'setup.model.required: to change the block runtime, provide --runtime and --model together; no configuration was written.',
+    modeloPendente: 'setup.model.required: this block has a pending model; provide --model before saving.',
+    origem: {
+        versionado: (name, local) => `Versioned setup in ${name}: it applies to every machine and changes through a PR.` +
+            (local ? ' This machine\'s local .orkastery/setup.json is ignored.' : ''),
+        local: 'Local setup for this machine (.orkastery/setup.json). To apply everywhere: ork setup versionar.',
+        padrao: 'No saved setup: the default applies. To apply everywhere: ork setup versionar.',
+    },
+    tabela: {
+        titulo: (tag, blocks, pauses) => `Setup for mode ${tag} (${blocks} block(s), ${pauses} pause(s))`,
+        cabecalho: ['BLOCK', 'PHASES', 'RUNTIME', 'MODEL', 'EFFORT', 'FALLBACK', 'ORIGIN'],
+        modeloPendente: '(model pending)', default: 'default', customizado: 'customized',
+        editar: (mode) => `Edit:     ork setup ${mode} --bloco N --runtime R --model M --effort E`,
+        fallback: (mode) => `Fallback: ork setup ${mode} --bloco N --fallback runtime:model[:effort],...   (--fallback "" removes it)`,
+        resetar: (mode, defaultValue) => `Reset:    ork setup ${mode} --reset   (returns to ${defaultValue})`,
+        runtimes: (list) => `Supported runtimes: ${list}`,
+    },
+    entrevista: {
+        titulo: '#setup interview: runtime + model + effort for each block of each mode',
+        ordem: (tags) => `Question order: ${tags}.`,
+        termina1: 'The interview ends after every mode is covered OR when the owner',
+        termina2: 'says it is complete: unanswered blocks keep their defaults.',
+        default: (defaultValue, exceptions) => `Post-install default: ${defaultValue} in every block${exceptions}`,
+        excecoes: (items) => `, except ${items}.`,
+        customizado: '  <- customized',
+        modeloPendente: '(model pending)',
+        bloco: (n, phases, config, mark) => `  block ${n}: ${phases}  [${config}]${mark}`,
+        ver: 'View a mode: ork setup <mode>',
+        editar: 'Edit a block: ork setup <mode> --bloco N --runtime R --model M --effort E',
+        resetar: 'Reset all:    ork setup --reset',
+    },
+    cli: {
+        versionado: (path) => `Setup versioned in ${path}.`,
+        levePorPr: '  Add it to the repository through a PR: from then on it applies to every machine, and ork setup <mode> --bloco N edits this file.',
+        worktreeConfirmada: (dir, root) => `Worktree folder "${dir}" confirmed on this machine for ${root}.`,
+        worktreeGravada: (file) => `  Saved in .orkastery/private/${file} (local, outside git). To undo: ork setup worktree revogar.`,
+        worktreeRevogada: 'Local worktree folder confirmation revoked.',
+        worktreeNaoHavia: 'There was no local worktree folder confirmation.',
+        worktreeSubcomando: (action) => `unknown subcommand: setup worktree ${action} (use confirmar [<dir>] or revogar)`,
+        worktreeManifesto: (value, dir, inside) => `worktree.dir in orkastery.yaml: ${value} (${dir}, ${inside ? 'inside' : 'outside'} the root)`,
+        confirmacaoLocal: (value) => `local confirmation on this machine: ${value}`,
+        nenhumaConfirmacao: (reason) => `none (${reason})`,
+        criacaoPermitida: 'worktree creation: allowed',
+        criacaoRecusada: (command) => `worktree creation: refused. ${command}`,
+        sandboxUso: 'usage: ork setup sandbox confirmar <read-only|workspace-write|danger-full-access> [--por Q]',
+        sandboxConfirmada: (posture, root) => `Sandbox posture "${posture}" confirmed on this machine for ${root}.`,
+        sandboxGravada: (path) => `  Saved in ${path} (local, outside git). To undo: ork setup sandbox revogar.`,
+        sandboxRevogada: 'Local sandbox posture confirmation revoked.',
+        sandboxNaoHavia: 'There was no local sandbox posture confirmation.',
+        sandboxSubcomando: (action) => `unknown subcommand: setup sandbox ${action} (use confirmar <posture> or revogar)`,
+        sandboxManifesto: (posture) => `runtime.sandbox in orkastery.yaml: ${posture}`,
+        despachoPermitido: 'codex dispatch: allowed',
+        despachoRecusado: (command) => `codex dispatch: refused. ${command}`,
+        resetado: 'Setup reset: every block in every mode returned to its default.',
+        modoDesconhecido: (mode, allowed) => `unknown conduction mode: "${mode}" (accepted: ${allowed})`,
+        modoResetado: (tag) => `Setup for mode ${tag} reset to its default.`,
+        informeBloco: 'to edit, provide the block: ork setup <mode> --bloco N [--runtime R] [--model M] [--effort E] [--fallback R:M,...]',
+        nadaParaEditar: 'nothing to edit: provide --runtime, --model, --effort, and/or --fallback together with --bloco',
+        edicaoRecusada: (error) => `edit refused: ${error}`,
+        blocoAlterado: (block, tag, from, to) => `Block ${block} of mode ${tag}: ${from} -> ${to}`,
+        gravado: (path) => `  saved in ${path}; setup_configured event recorded in the project ledger`,
+    },
+};