@orkastery/cli 0.5.6 → 0.6.1

package/dist/locale-retry.js

@@ -63,8 +63,9 @@ exports.RETRY_PT_BR = {
             correcao: 'publique a candidata, aguarde o check obrigatório e repita o SHIP; se reprovou, corrija a causa registrada no runner',
         },
         'runtime.unavailable': {
-            porque: 'falha de infraestrutura no despacho nao e falha de conteudo: o MESMO prompt, com o mesmo sha256, e redespachado sem alterar uma virgula',
-            correcao: 'ork retry run <thread> redespacha o prompt ja gravado em disco',
+            porque: 'falha de infraestrutura no despacho nao e falha de conteudo: o MESMO prompt, com o mesmo sha256, sobe a escada de recuperacao ' +
+                '(reerguer o daemon do runtime, o fallback do bloco, outro perfil) sem alterar uma virgula, e so depois dela o dono e chamado',
+            correcao: 'ork retry run <thread> sobe a escada com o prompt ja gravado em disco',
         },
         'runtime.silencio': {
             porque: 'fase sem heartbeat: retomar o despacho original com hash conferido e limite de tentativas',
@@ -75,7 +76,7 @@ exports.RETRY_PT_BR = {
             correcao: 'ork retry list mostra a fila; ork retry resume retoma o que ja liberou',
         },
         'runtime.quota-exhausted': {
-            porque: 'a cota ou os creditos da CONTA acabaram, nao a infraestrutura: o perfil sai do rodizio ate o prazo e o MESMO prompt, com o mesmo sha256, segue no proximo perfil, no runtime de fallback ou na fila ate o menor prazo',
+            porque: 'a cota ou os creditos da CONTA acabaram, nao a infraestrutura: o perfil sai do rodizio ate o prazo; o prompt original, se o intervalo ficou vazio, ou um checkpoint da producao parcial segue no proximo perfil, no runtime de fallback ou na fila ate o menor prazo',
             correcao: 'ork accounts list mostra o perfil esgotado; ork retry run <thread> rotaciona o prompt ja gravado',
         },
         'runtime.auth-missing': {
@@ -144,6 +145,52 @@ exports.RETRY_PT_BR = {
     coberturas: { completa: 'completa', parcial: 'parcial' },
     fila: 'Fila de rate limit desta thread:',
     pedidoNaFila: (id, fase, quando, estimada) => `  ${id}  ${fase}  libera em ${quando}${estimada ? ' (janela estimada)' : ''}`,
+    complementar: {
+        politicaTitulo: 'Politica de retry por motivo tipado de gate (bloco B3)',
+        colunasPolitica: ['MOTIVO TIPADO', 'ACAO DE RETRY', 'AUTOMATICA', 'POR QUE'],
+        sim: 'sim', nao: 'nao',
+        politicaFecho: [
+            'A politica e a MESMA em todos os modos: o modo afrouxa a pausa, nunca a',
+            'verificacao. cost.violation nunca recebe retry automatico, e o limite de',
+            'escalacao (retry.max_tentativas) pausa qualquer modo, inclusive #Auto.',
+        ],
+        motivoDesconhecido: (motivo) => `motivo tipado desconhecido: ${motivo}`,
+        conhecidos: (lista) => `  conhecidos: ${lista}`,
+        motivo: (valor) => `motivo tipado: ${valor}`,
+        significado: (valor) => `  significado  ${valor}`,
+        acao: (valor) => `  acao         ${valor}`,
+        automatica: (valor) => `  automatica   ${valor}`,
+        porque: (valor) => `  por que      ${valor}`,
+        correcao: (valor) => `  correcao     ${valor}`,
+        usoParse: 'uso: ork retry parse --stderr "<texto do stderr do adapter>"',
+        semSinal: 'Nenhum sinal de rate limit reconhecido neste texto.',
+        sinal: 'Sinal de rate limit reconhecido no stderr do runtime:',
+        fonte: (valor) => `  fonte da hora  ${valor}`,
+        reset: (valor) => `  reset em       ${valor}`,
+        semHora: '(o runtime nao disse a hora)',
+        trecho: (valor) => `  trecho         ${valor}`,
+        estimada: [
+            '  Sem hora no texto, a fila usa retry.janela_padrao_min do manifesto e marca',
+            '  o pedido como janela ESTIMADA. O `ork` nao inventa horario de reset.',
+        ],
+        proxima: (quando, falta) => `Proxima janela: ${quando} (${falta}).`,
+        retome: 'Retome com: ork retry resume',
+        usoCancel: 'uso: ork retry cancel <id> --motivo "<motivo>"',
+        cancelado: (id) => `Pedido ${id} cancelado na fila de rate limit.`,
+        thread: (valor) => `  thread   ${valor}`, fase: (valor) => `  fase     ${valor}`,
+        motivoLinha: (valor) => `  motivo   ${valor}`,
+        desconhecido: (sub) => `subcomando desconhecido: retry ${sub}`,
+        filaVazia: 'Fila de rate limit vazia: nenhuma fase morreu por limite de uso neste projeto.',
+        colunasFila: ['ID', 'THREAD', 'FASE', 'ESTADO', 'LIBERA EM', 'ORIGEM DA HORA', 'FALTA', 'TENT'],
+        estados: { aguardando: 'aguardando', retomado: 'retomado', escalado: 'escalado', cancelado: 'cancelado' },
+        horaEstimada: (fonte) => `estimada (${fonte})`, horaRuntime: (fonte) => `dita pelo runtime (${fonte})`,
+        retomadaVazia: 'Nenhum pedido da fila de rate limit com a janela liberada agora.',
+        retomadaCabecalho: (id, thread, fase) => `${id}  thread ${thread}  fase ${fase}`,
+        playbook: (v) => `  playbook    ${v}`, slug: (v) => `  slug        ${v}`,
+        retomada: (sim, sessao) => `  retomada    ${sim ? `sim (sessao ${sessao})` : 'nao'}`,
+        motivoRetomada: (v) => `  motivo      ${v}`, detalhe: (v) => `  detalhe     ${v}`,
+        estado: (v) => `  estado      ${v}`,
+    },
     // planejarRetry: a razao do plano (vai ao ledger)
     semReprovacao: 'nenhum gate reprovado no ledger desta thread',
     nadaARepetir: 'nao ha o que repetir: o ledger da thread nao tem reprovacao tipada pendente',
@@ -164,6 +211,24 @@ exports.RETRY_PT_BR = {
     correcoesNaRodada: (n, rodada, veredito) => `${n} correcao(oes) na rodada ${rodada}` + (veredito !== null ? `; CHECK-REVERIFY: ${veredito}` : ''),
     semDespachoFalho: (fase, thread) => `nao ha despacho falho registrado em ${fase} com prompt gravado: ` +
         `rode a fase de novo com \`ork phase run ${thread} ${fase} --prompt "..."\``,
+    perfilPedidoRecusado: (id, runtime, motivo, detalhe) => `perfil pedido "${id}" (${runtime}) preservado, mas indisponivel por ${motivo}: ${detalhe}. ` +
+        'Nenhuma outra conta foi usada.',
+    correcaoDoPerfilPedido: (id, runtime, motivo, thread) => {
+        if (motivo === 'runtime.auth-missing')
+            return `refaca o login de assinatura do perfil "${id}" no ${runtime}, rode ` +
+                `\`ork accounts check ${id}\` e repita \`ork retry run ${thread}\``;
+        if (motivo === 'runtime.quota-exhausted')
+            return `aguarde o perfil "${id}" voltar a ativo em \`ork accounts list\` e ` +
+                `repita \`ork retry run ${thread}\`; para autorizar outra conta, rode a fase novamente sem \`--perfil\``;
+        if (motivo === 'runtime.profile-invalid')
+            return `rode \`ork accounts list\` e restaure o perfil "${id}" no runtime ${runtime}, ` +
+                'ou rode a fase novamente com um perfil valido ou sem `--perfil`';
+        if (motivo === 'cost.violation')
+            return `refaca o login de assinatura do perfil "${id}", rode ` +
+                `\`ork accounts check ${id}\` e repita \`ork retry run ${thread}\`; perfil de provider pago nunca despacha`;
+        return `confira o runtime ${runtime} e o perfil "${id}" com \`ork accounts check ${id}\`; depois repita ` +
+            `\`ork retry run ${thread}\``;
+    },
     semConfianca: (motivo, cwd, thread) => `${motivo}: o runtime ainda nao confia em ${cwd}; nada foi despachado. ` +
         `Rode \`cd ${cwd} && claude\`, aceite a confianca e repita \`ork retry run ${thread}\``,
     /** RM-063 (F3): a sessao viva na thread; redespachar abriria a segunda na mesma worktree. */
@@ -200,6 +265,30 @@ exports.RETRY_PT_BR = {
     ensaioDoRedespacho: 'ensaio (--dry-run): comando montado, nada despachado',
     semSessionId: 'sem sessionId na saida do runtime',
     redespachada: (sessao, sha, perfil, runtime) => `sessao ${sessao} despachada com o mesmo prompt sha256 ${sha}` + (perfil ? ` no perfil ${perfil} (${runtime})` : ''),
+    /** RM-063 (F4): a escada de recuperacao do runtime. Vai ao ledger em pt-BR; a impressao remonta no locale. */
+    escada: {
+        degraus: { 'reerguer-daemon': 'reerguer o daemon do runtime', 'fallback-do-bloco': 'o fallback do bloco',
+            'outro-perfil': 'outro perfil do runtime' },
+        pulos: { 'sem-fallback': 'o bloco nao tem fallback de runtime',
+            'adaptador-ausente': 'nenhum fallback tem adaptador instalado neste projeto',
+            'fallback-sem-destino': 'nenhum alvo do fallback do bloco tem perfil disponivel',
+            'sem-outro-perfil': 'o runtime nao tem outro perfil disponivel',
+            'cota-sem-sinal-tipado': 'o runtime ainda nao tipa a cota esgotada e fica fora da troca automatica de conta' },
+        resultados: { redespachada: 'redespachada', falhou: 'falhou', pulado: 'pulado', interrompido: 'interrompido' },
+        linhaDoDegrau: (n, tipo, resultado, motivo) => `degrau ${n} (${tipo}): ${resultado}${motivo ? ` (${motivo})` : ''}`,
+        noPlano: (n, tipo) => `  escada          degrau ${n} de 3, ${tipo}`,
+        noPlanoEsgotada: '  escada          os 3 degraus acabaram neste episodio',
+        esgotada: (resumo) => `a escada de recuperacao do runtime acabou sem sessao (${resumo}): ` +
+            'escalacao tipada pausa qualquer modo, inclusive #Auto',
+        correcao: (conferir, retomar) => `confira o runtime (${conferir}) e retome com o mesmo prompt: ${retomar}`,
+        proximo: (n, tipo) => `o mesmo prompt sobe a escada de recuperacao no degrau ${n}: ${tipo}`,
+        ensaio: (n, tipo, destino) => `ensaio: o degrau ${n} (${tipo}) mandaria o mesmo prompt a ${destino}`,
+        ensaioPulado: (n, tipo, pulo) => `ensaio: o degrau ${n} (${tipo}) seria pulado: ${pulo}`,
+        ensaioEsgotada: 'ensaio: nenhum degrau da escada tem destino agora; o dono seria chamado',
+        lancou: (erro) => `runtime.unavailable: o adaptador lancou no redespacho: ${erro}`,
+        semResposta: (vezes, detalhe) => `o runtime nao respondeu a prova de vida em ${vezes} tentativa(s) seguidas ` +
+            `(${detalhe}), mesmo depois de reerguer o daemon: sem a prova, nada foi redespachado`,
+    },
 };
 exports.RETRY_EN = {
     politica: {
@@ -252,8 +341,10 @@ exports.RETRY_EN = {
             correcao: 'publish the candidate, wait for the required check and run SHIP again; if it failed, fix the cause recorded on the runner',
         },
         'runtime.unavailable': {
-            porque: 'an infrastructure failure in the dispatch is not a content failure: the SAME prompt, with the same sha256, is dispatched again without changing a comma',
-            correcao: '`ork retry run <thread>` re-dispatches the prompt already on disk',
+            porque: 'an infrastructure failure in the dispatch is not a content failure: the SAME prompt, with the same sha256, climbs the ' +
+                'recovery ladder (bring the runtime daemon back up, the block fallback, another profile) without changing a comma, and only ' +
+                'after it is the owner called',
+            correcao: '`ork retry run <thread>` climbs the ladder with the prompt already on disk',
         },
         'runtime.silencio': {
             porque: 'phase with no heartbeat: resume the original dispatch with the hash checked and an attempt limit',
@@ -264,7 +355,7 @@ exports.RETRY_EN = {
             correcao: '`ork retry list` shows the queue; `ork retry resume` resumes what is already released',
         },
         'runtime.quota-exhausted': {
-            porque: 'the ACCOUNT quota or credits ran out, not the infrastructure: the profile leaves the rotation until the deadline and the SAME prompt, with the same sha256, goes on to the next profile, the fallback runtime or the queue until the earliest deadline',
+            porque: 'the ACCOUNT quota or credits ran out, not the infrastructure: the profile leaves the rotation until the deadline; the original prompt after an empty interval, or a checkpoint of partial production, goes on to the next profile, the fallback runtime or the queue until the earliest deadline',
             correcao: '`ork accounts list` shows the exhausted profile; `ork retry run <thread>` rotates the prompt already written',
         },
         'runtime.auth-missing': {
@@ -330,6 +421,52 @@ exports.RETRY_EN = {
     coberturas: { completa: 'full', parcial: 'partial' },
     fila: 'Rate limit queue for this thread:',
     pedidoNaFila: (id, fase, quando, estimada) => `  ${id}  ${fase}  released at ${quando}${estimada ? ' (estimated window)' : ''}`,
+    complementar: {
+        politicaTitulo: 'Retry policy by typed gate reason (block B3)',
+        colunasPolitica: ['TYPED REASON', 'RETRY ACTION', 'AUTOMATIC', 'WHY'],
+        sim: 'yes', nao: 'no',
+        politicaFecho: [
+            'The policy is the SAME in every mode: the mode loosens pauses, never',
+            'verification. cost.violation never gets an automatic retry, and the',
+            'escalation limit (retry.max_tentativas) pauses every mode, including #Auto.',
+        ],
+        motivoDesconhecido: (reason) => `unknown typed reason: ${reason}`,
+        conhecidos: (list) => `  known: ${list}`,
+        motivo: (value) => `typed reason: ${value}`,
+        significado: (value) => `  meaning      ${value}`,
+        acao: (value) => `  action       ${value}`,
+        automatica: (value) => `  automatic    ${value}`,
+        porque: (value) => `  why          ${value}`,
+        correcao: (value) => `  fix          ${value}`,
+        usoParse: 'usage: ork retry parse --stderr "<adapter stderr text>"',
+        semSinal: 'No rate-limit signal was recognized in this text.',
+        sinal: 'Rate-limit signal recognized in runtime stderr:',
+        fonte: (value) => `  time source   ${value}`,
+        reset: (value) => `  reset at      ${value}`,
+        semHora: '(the runtime did not provide a time)',
+        trecho: (value) => `  excerpt       ${value}`,
+        estimada: [
+            '  With no time in the text, the queue uses retry.janela_padrao_min from the manifest',
+            '  and marks the request as an ESTIMATED window. `ork` does not invent a reset time.',
+        ],
+        proxima: (when, remaining) => `Next window: ${when} (${remaining}).`,
+        retome: 'Resume with: ork retry resume',
+        usoCancel: 'usage: ork retry cancel <id> --motivo "<reason>"',
+        cancelado: (id) => `Request ${id} cancelled in the rate-limit queue.`,
+        thread: (value) => `  thread   ${value}`, fase: (value) => `  phase    ${value}`,
+        motivoLinha: (value) => `  reason   ${value}`,
+        desconhecido: (sub) => `unknown subcommand: retry ${sub}`,
+        filaVazia: 'Rate-limit queue is empty: no phase died from a usage limit in this project.',
+        colunasFila: ['ID', 'THREAD', 'PHASE', 'STATE', 'RELEASES AT', 'TIME SOURCE', 'LEFT', 'TRY'],
+        estados: { aguardando: 'waiting', retomado: 'resumed', escalado: 'escalated', cancelado: 'cancelled' },
+        horaEstimada: (source) => `estimated (${source})`, horaRuntime: (source) => `reported by runtime (${source})`,
+        retomadaVazia: 'No rate-limit queue request has a released window now.',
+        retomadaCabecalho: (id, thread, phase) => `${id}  thread ${thread}  phase ${phase}`,
+        playbook: (v) => `  playbook    ${v}`, slug: (v) => `  slug        ${v}`,
+        retomada: (yes, session) => `  resumed     ${yes ? `yes (session ${session})` : 'no'}`,
+        motivoRetomada: (v) => `  reason      ${v}`, detalhe: (v) => `  detail      ${v}`,
+        estado: (v) => `  state       ${v}`,
+    },
     semReprovacao: 'no failed gate in the ledger of this thread',
     nadaARepetir: 'nothing to repeat: the thread ledger has no pending typed failure',
     limiteDeEscalacao: (tentativas, motivo, fase, limite) => `${tentativas} automatic attempt(s) for ${motivo} in ${fase}, at the manifest limit of ${limite}: ` +
@@ -348,6 +485,24 @@ exports.RETRY_EN = {
     correcoesNaRodada: (n, rodada, veredito) => `${n} fix(es) in round ${rodada}` + (veredito !== null ? `; CHECK-REVERIFY: ${veredito}` : ''),
     semDespachoFalho: (fase, thread) => `no failed dispatch with a written prompt is recorded in ${fase}: ` +
         `run the phase again with \`ork phase run ${thread} ${fase} --prompt "..."\``,
+    perfilPedidoRecusado: (id, runtime, motivo, detalhe) => `requested profile "${id}" (${runtime}) was preserved but is unavailable because of ${motivo}: ${detalhe}. ` +
+        'No other account was used.',
+    correcaoDoPerfilPedido: (id, runtime, motivo, thread) => {
+        if (motivo === 'runtime.auth-missing')
+            return `sign profile "${id}" back in to its ${runtime} subscription, run ` +
+                `\`ork accounts check ${id}\`, and repeat \`ork retry run ${thread}\``;
+        if (motivo === 'runtime.quota-exhausted')
+            return `wait until profile "${id}" is active again in \`ork accounts list\`, then ` +
+                `repeat \`ork retry run ${thread}\`; to authorize another account, run the phase again without \`--perfil\``;
+        if (motivo === 'runtime.profile-invalid')
+            return `run \`ork accounts list\` and restore profile "${id}" under runtime ${runtime}, ` +
+                'or run the phase again with a valid profile or without `--perfil`';
+        if (motivo === 'cost.violation')
+            return `sign profile "${id}" back in through the subscription, run ` +
+                `\`ork accounts check ${id}\`, and repeat \`ork retry run ${thread}\`; a paid-provider profile is never dispatched`;
+        return `check runtime ${runtime} and profile "${id}" with \`ork accounts check ${id}\`; then repeat ` +
+            `\`ork retry run ${thread}\``;
+    },
     semConfianca: (motivo, cwd, thread) => `${motivo}: the runtime does not trust ${cwd} yet; nothing was dispatched. ` +
         `Run \`cd ${cwd} && claude\`, accept the trust and repeat \`ork retry run ${thread}\``,
     sessaoAindaViva: (sessao, thread) => `session ${sessao} is still working on the thread in the runtime; nothing was ` +
@@ -382,4 +537,26 @@ exports.RETRY_EN = {
     ensaioDoRedespacho: 'dry run (--dry-run): command built, nothing dispatched',
     semSessionId: 'no sessionId in the runtime output',
     redespachada: (sessao, sha, perfil, runtime) => `session ${sessao} dispatched with the same prompt sha256 ${sha}` + (perfil ? ` on profile ${perfil} (${runtime})` : ''),
+    escada: {
+        degraus: { 'reerguer-daemon': 'bring the runtime daemon back up', 'fallback-do-bloco': 'the block fallback',
+            'outro-perfil': 'another runtime profile' },
+        pulos: { 'sem-fallback': 'the block has no runtime fallback', 'adaptador-ausente': 'no fallback has an adapter installed in this project',
+            'fallback-sem-destino': 'no target of the block fallback has an available profile',
+            'sem-outro-perfil': 'the runtime has no other available profile',
+            'cota-sem-sinal-tipado': 'the runtime does not type the exhausted quota yet and stays out of the automatic account switch' },
+        resultados: { redespachada: 'dispatched again', falhou: 'failed', pulado: 'skipped', interrompido: 'interrupted' },
+        linhaDoDegrau: (n, tipo, resultado, motivo) => `step ${n} (${tipo}): ${resultado}${motivo ? ` (${motivo})` : ''}`,
+        noPlano: (n, tipo) => `  ladder          step ${n} of 3, ${tipo}`,
+        noPlanoEsgotada: '  ladder          the 3 steps are spent in this episode',
+        esgotada: (resumo) => `the runtime recovery ladder ended with no session (${resumo}): ` +
+            'a typed escalation pauses any mode, #Auto included',
+        correcao: (conferir, retomar) => `check the runtime (${conferir}) and resume with the same prompt: ${retomar}`,
+        proximo: (n, tipo) => `the same prompt climbs the recovery ladder at step ${n}: ${tipo}`,
+        ensaio: (n, tipo, destino) => `dry run: step ${n} (${tipo}) would send the same prompt to ${destino}`,
+        ensaioPulado: (n, tipo, pulo) => `dry run: step ${n} (${tipo}) would be skipped: ${pulo}`,
+        ensaioEsgotada: 'dry run: no step of the ladder has a target now; the owner would be called',
+        lancou: (erro) => `runtime.unavailable: the adapter threw in the redispatch: ${erro}`,
+        semResposta: (vezes, detalhe) => `the runtime did not answer the liveness proof in ${vezes} attempt(s) in a row ` +
+            `(${detalhe}), even after bringing the daemon back up: without the proof, nothing was redispatched`,
+    },
 };

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`,
+    },
+};