@orkastery/cli 0.5.3 → 0.6.0

package/dist/locale-audit.js

@@ -0,0 +1,199 @@
+"use strict";
+/** RM-061 F3d: moldura humana do ciclo de auditoria; ids, caminhos e JSON nao mudam. */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AUDIT_EN = exports.AUDIT_PT_BR = void 0;
+/** O uso do subcomando pedido, so quando ele e chave propria do mapa (nunca um membro do prototipo do objeto). */
+function usoDe(usos, sub) {
+    return Object.hasOwn(usos, sub) ? usos[sub] : undefined;
+}
+exports.AUDIT_PT_BR = {
+    packs: {
+        titulo: (estagio) => `Packs de auditoria periodica${estagio ? ` (estagio declarado do projeto: ${estagio})` : ''}`,
+        ativo: (packs) => `Ativos aqui e agora: ${packs}`,
+        postura: (postura) => `Postura: ${postura}`,
+        cabecalho: ['PACK', 'ATIVO A PARTIR DE', 'ATIVO AQUI', 'FONTE', 'REGRAS', 'POSTURA', 'TITULO'],
+        hardening: 'Hardening por estagio (visao, secao 5.2):',
+        posturaLinha: (descricao) => `postura: ${descricao}`,
+        sim: 'sim', nao: 'nao',
+        detalhe: {
+            titulo: (id, titulo) => `Pack ${id}: ${titulo}`,
+            ativoDesde: (estagio) => `  ativo a partir do estagio: ${estagio}`,
+            fonte: (fonte) => `  fonte de evidencia: ${fonte}`,
+            fonteLedger: 'ledger e MASTER logs', fonteCodigo: 'arvore de codigo',
+            nesteProjeto: (estagio, ativo, postura) => `  neste projeto (stage ${estagio}): ${ativo ? 'ATIVO' : 'inativo'}${ativo ? `, postura ${postura}` : ''}`,
+            regras: '  Regras auditadas:', evidencia: (texto) => `         evidencia: ${texto}`,
+        },
+    },
+    rodadas: {
+        vazia: 'Nenhuma rodada de auditoria em .orkastery/audits. Rode: ork audit run <pack>',
+        cabecalho: ['RODADA', 'PACK', 'PERFIL', 'ESTAGIO', 'STATUS', 'MOTIVO', 'ACHADOS', 'CLAIMS', 'ESCOPO'],
+        sustentado: 'sustentado', reprovado: 'REPROVADO', naoVerificado: 'nao verificado',
+        titulo: (id) => `Rodada de auditoria ${id}`,
+        campo: (nome, valor) => `  ${nome.padEnd(11)} ${valor}`,
+        campos: { pack: 'pack', produto: 'produto', estagio: 'estagio', escopo: 'escopo', graphify: 'graphify', custo: 'custo', janela: 'janela', autorizada: 'autorizada', runtime: 'runtime', prompt: 'prompt', status: 'status', superficie: 'superficie', detalhe: 'detalhe' },
+        perfil: (p) => `(perfil ${p})`, postura: (p) => `postura ${p}`,
+        custo: (effort, model) => `effort ${effort}, model ${model}`,
+        autorizada: (por) => `fora da janela por ${por}`,
+        sessaoAusente: '(nao despachada)', promptAusente: '(nao montado)', motivo: (m) => `(motivo tipado: ${m})`,
+        superficieResumo: (registrados, confirmar, frameworks) => `registrados ${registrados}, a confirmar ${confirmar}, frameworks: ${frameworks}`,
+        nenhumFramework: '(nenhum reconhecido)', achados: (n) => `  Achados (${n}):`,
+        nenhumAchado: '    (nenhum achado registrado nesta rodada ainda)',
+        claims: (ok, motivos, head) => `  Claims do auditor: ${ok ? 'SUSTENTADAS' : 'REPROVADAS'} (motivos: ${motivos || 'nenhum'}) no HEAD ${head}`,
+        claimsPendentes: (id) => `  Claims do auditor: NAO verificadas. Rode: ork audit verify ${id}`,
+        relatorio: (id) => `  Relatorio com o bloco de propostas: ork audit report ${id}`,
+        ledgerVazio: (id) => `Ledger vazio para a rodada ${id}.`,
+        ledgerCabecalho: ['QUANDO', 'EVENTO', 'DETALHE'],
+        detalhes: { achado: (v) => `achado ${v}`, motivo: (v) => `motivo ${v}`, sessao: (v) => `sessao ${v}`, veredito: (v) => `veredito: ${v}`, destino: (v) => `destino ${v}`, thread: (v) => `thread ${v}` },
+        boardVazio: 'board de divida vazio', board: (total, abertos) => `${total} achado(s) no board de divida, ${abertos} aberto(s)`,
+    },
+    divida: {
+        vazia: (pack) => `Board de divida vazio${pack ? ` para o pack ${pack}` : ''}.\nRode uma auditoria: ork audit run <pack>`,
+        cabecalho: ['ID', 'PACK', 'REGRA', 'SEVERIDADE', 'CLAIM', 'ESTADO', 'ESTIMATIVA', 'IRREVERSIVEL', 'EVIDENCIA', 'TITULO'],
+        sim: 'SIM', nao: 'nao', titulo: (caminho) => `Board de divida do projeto (${caminho})`,
+        recorrencia: 'Recorrencia (2 propoem controle, 3 propoem bloqueante; o `ork` nunca promove sozinho):',
+        nenhuma: '  (nenhuma regra recorrente ainda)',
+        item: (pack, regra, n, promocao, ids) => `  ${pack} ${regra}: ${n}x -> promocao proposta: ${promocao} (${ids})`,
+        resumo: (abertos, total) => `abertos: ${abertos} | total listado: ${total}`,
+        thread: 'Achado vira thread com: ork thread new "<nome>" --from-finding <ID>',
+    },
+    superficie: {
+        vazia: (detalhe) => `Nenhum achado de superficie de ataque. ${detalhe}`,
+        cabecalho: ['REGRA', 'SEVERIDADE', 'CONFIANCA', 'FRAMEWORK', 'ROTA', 'EVIDENCIA', 'TITULO'],
+        titulo: 'Varredura deterministica da superficie de ataque de rede (pack security-privacy, SP8..SP12)',
+        campo: (nome, valor) => `  ${nome.padEnd(13)} ${valor}`,
+        campos: { raiz: 'raiz', escopo: 'escopo', frameworks: 'frameworks', teto: 'teto' },
+        nenhumFramework: '(nenhum reconhecido)', teto: (n) => `${n} achado(s) por regra`,
+        truncado: (n, regra) => `  ATENCAO: ${n} achado(s) de ${regra} ficaram fora do teto desta varredura.`,
+        baixa: (n, descricao) => `  ${n} achado(s) sairam com confianca baixa: ${descricao}`,
+        claims: 'Cada achado carrega o comando que o reexecuta no HEAD real (o auditor nao tem self-report).',
+        registrar: 'Para registrar no board de divida de uma rodada: ork audit surface --registrar <rodada>',
+    },
+    cli: {
+        packs: (lista) => `  packs: ${lista}`,
+        lintTitulo: (raiz) => `Lint dos templates de auditoria${raiz ? ` (projeto ${raiz})` : ' (somente embutidos)'}`,
+        lintItem: (gravidade, template, regra) => `  [${gravidade}] ${template} :: ${regra}`,
+        lintDetalhe: (detalhe) => `           ${detalhe}`,
+        lintOk: (n) => `  nenhum problema em ${n} template(s)`,
+        lintResumo: (templates, erros, avisos) => `templates: ${templates} | erros: ${erros} | avisos: ${avisos}`,
+        bloqueada: (id) => `Rodada de auditoria ${id} BLOQUEADA.`,
+        motivo: (v) => `  motivo tipado: ${v}`, detalhe: (v) => `  detalhe: ${v}`,
+        estado: (id) => `  estado da rodada: .orkastery/audits/${id}/run.json`,
+        ensaio: (id) => `Simulacao (--dry-run) da rodada ${id}: nada foi despachado.`,
+        despachada: (id, runtime) => `Rodada de auditoria ${id} despachada pelo runtime adapter ${runtime}.`,
+        verificada: (ok) => `  verificada no runtime: ${ok ? 'sim' : 'NAO (confira `ork sessions`)'}`,
+        superficieDry: (id) => `              nada registrado no board (--dry-run). Para gravar: ork audit surface --registrar ${id}`,
+        superficieBoard: (n, confirmar) => `              ${n} achado(s) de superficie ja no board de divida${confirmar > 0 ? `, ${confirmar} com confianca baixa (pedem confirmacao humana)` : ''}`,
+        proposta: 'A rodada termina em PROPOSTA para o roadmap, nunca em correcao aplicada.',
+        depois: (id) => `Depois dos achados: ork audit verify ${id} && ork audit report ${id}`,
+        board: (resumo) => `Board de divida: ${resumo}`,
+        ingestao: (id, n) => `Ingestao da rodada ${id}: ${n} achado(s) no board de divida.`,
+        memoriaMuitas: (detalhe) => `Memoria (orkmind): propostas na colecao roadmap, ${detalhe}.`,
+        memoriaUma: (detalhe) => `Memoria (orkmind): proposta na colecao roadmap, ${detalhe}.`,
+        duplicados: (ids) => `Ja registrados nesta rodada, ignorados (a ingestao e idempotente): ${ids}`,
+        recusados: (n) => `RECUSADOS (${n}):`, recusado: (n, erro) => `  achado #${n}: ${erro}`,
+        prove: (id) => `Prove os achados antes de qualquer thread: ork audit verify ${id}`,
+        achadoRegistrado: (achado, rodada) => `Achado ${achado} registrado no board de divida da rodada ${rodada}.`,
+        estadoReservado: 'o estado `virou-thread` e carimbado pelo proprio `ork thread new --from-finding`.',
+        achadoEstado: (id, estado) => `Achado ${id} agora esta ${estado}.`,
+        findingDesconhecido: (acao) => `subcomando desconhecido: audit finding ${acao}`,
+        verifyTitulo: (id) => `Claims dos achados da rodada ${id}, reexecutadas no HEAD real.`,
+        verifyHead: (head) => `  HEAD real   ${head}`, verifyDir: (cwd) => `  diretorio   ${cwd}`,
+        verifyVazio: '  (nenhum achado aberto nesta rodada)',
+        verifyClaim: (id, ok, alegacao) => `  ${id}  verificado: ${ok ? 'sim' : 'NAO'}  ${alegacao}`,
+        arquivo: (v) => `      arquivo: ${v}`, comandos: (v) => `      comando(s): ${v}`,
+        semComando: '      sem comando de verificacao', motivoDetalhe: (m, d) => `      motivo tipado: ${m} (${d})`,
+        vereditoOk: 'Veredito: ACHADOS SUSTENTADOS (o auditor provou o que alegou).',
+        vereditoRuim: (m) => `Veredito: REPROVADO. Motivos tipados: ${m}`,
+        unverifiable: '  aviso: achado sem comando de verificacao avisa e nao bloqueia (regra do gate do B1).',
+        relatorio: (caminho) => `(relatorio gravado em ${caminho})`, publicado: (caminho) => `(publicado em ${caminho})`,
+        rodadaRegistrada: (id, n) => `Rodada ${id}: ${n} achado(s) registrado(s) no board de divida.`,
+        jaRegistrados: (ids) => `  ja registrados nesta rodada: ${ids}`,
+        recusadoSuperficie: (regra, arquivo, linha, erro) => `  RECUSADO ${regra} ${arquivo}:${linha}: ${erro}`,
+    },
+    // GO-FIX 3: so a propria chave do mapa conta; `constructor` ou `toString` do prototipo eram impressos no lugar da recusa.
+    uso: (sub) => usoDe({ run: 'uso: ork audit run <pack> [--profile P] [--since Nd]', show: 'uso: ork audit show <rodada> [--ledger]', prompt: 'uso: ork audit prompt <pack> [--since Nd]', ingest: 'uso: ork audit ingest <rodada> --arquivo <achados.json>', verify: 'uso: ork audit verify <rodada>', report: 'uso: ork audit report <rodada> [--publicar]' }, sub) ?? `subcomando desconhecido: audit ${sub}`,
+    erro: { estagio: (v) => `estagio invalido: "${v}". Use: nascente | crescendo | maduro`, pack: (v, lista) => `pack desconhecido: "${v}". Use um de: ${lista}`, regra: (v, lista) => `regra desconhecida: "${v}". Use uma de: ${lista}`, limite: (v) => `--limite invalido: "${v}". Use um inteiro >= 1.` },
+};
+exports.AUDIT_EN = {
+    packs: {
+        titulo: (stage) => `Periodic audit packs${stage ? ` (declared project stage: ${stage})` : ''}`,
+        ativo: (packs) => `Active here and now: ${packs}`, postura: (posture) => `Posture: ${posture}`,
+        cabecalho: ['PACK', 'ACTIVE FROM', 'ACTIVE HERE', 'SOURCE', 'RULES', 'POSTURE', 'TITLE'],
+        hardening: 'Hardening by stage (vision, section 5.2):', posturaLinha: (description) => `posture: ${description}`,
+        sim: 'yes', nao: 'no',
+        detalhe: {
+            titulo: (id, title) => `Pack ${id}: ${title}`, ativoDesde: (stage) => `  active from stage: ${stage}`,
+            fonte: (source) => `  evidence source: ${source}`, fonteLedger: 'ledger and MASTER logs', fonteCodigo: 'code tree',
+            nesteProjeto: (stage, active, posture) => `  in this project (stage ${stage}): ${active ? 'ACTIVE' : 'inactive'}${active ? `, posture ${posture}` : ''}`,
+            regras: '  Audited rules:', evidencia: (value) => `         evidence: ${value}`,
+        },
+    },
+    rodadas: {
+        vazia: 'No audit run in .orkastery/audits. Run: ork audit run <pack>',
+        cabecalho: ['RUN', 'PACK', 'PROFILE', 'STAGE', 'STATUS', 'REASON', 'FINDINGS', 'CLAIMS', 'SCOPE'],
+        sustentado: 'sustained', reprovado: 'FAILED', naoVerificado: 'not verified', titulo: (id) => `Audit run ${id}`,
+        campo: (name, value) => `  ${name.padEnd(11)} ${value}`,
+        campos: { pack: 'pack', produto: 'product', estagio: 'stage', escopo: 'scope', graphify: 'graphify', custo: 'cost', janela: 'window', autorizada: 'authorized', runtime: 'runtime', prompt: 'prompt', status: 'status', superficie: 'surface', detalhe: 'detail' },
+        perfil: (p) => `(profile ${p})`, postura: (p) => `posture ${p}`, custo: (effort, model) => `effort ${effort}, model ${model}`,
+        autorizada: (by) => `outside the window by ${by}`, sessaoAusente: '(not dispatched)', promptAusente: '(not assembled)', motivo: (m) => `(typed reason: ${m})`,
+        superficieResumo: (registered, confirm, frameworks) => `registered ${registered}, to confirm ${confirm}, frameworks: ${frameworks}`,
+        nenhumFramework: '(none recognized)', achados: (n) => `  Findings (${n}):`, nenhumAchado: '    (no finding recorded in this run yet)',
+        claims: (ok, reasons, head) => `  Auditor claims: ${ok ? 'SUSTAINED' : 'FAILED'} (reasons: ${reasons || 'none'}) at HEAD ${head}`,
+        claimsPendentes: (id) => `  Auditor claims: NOT verified. Run: ork audit verify ${id}`,
+        relatorio: (id) => `  Report with the proposals block: ork audit report ${id}`,
+        ledgerVazio: (id) => `Empty ledger for run ${id}.`, ledgerCabecalho: ['WHEN', 'EVENT', 'DETAIL'],
+        detalhes: { achado: (v) => `finding ${v}`, motivo: (v) => `reason ${v}`, sessao: (v) => `session ${v}`, veredito: (v) => `verdict: ${v}`, destino: (v) => `destination ${v}`, thread: (v) => `thread ${v}` },
+        boardVazio: 'empty debt board', board: (total, open) => `${total} finding(s) in the debt board, ${open} open`,
+    },
+    divida: {
+        vazia: (pack) => `Empty debt board${pack ? ` for pack ${pack}` : ''}.\nRun an audit: ork audit run <pack>`,
+        cabecalho: ['ID', 'PACK', 'RULE', 'SEVERITY', 'CLAIM', 'STATUS', 'ESTIMATE', 'IRREVERSIBLE', 'EVIDENCE', 'TITLE'],
+        sim: 'YES', nao: 'no', titulo: (path) => `Project debt board (${path})`,
+        recorrencia: 'Recurrence (2 propose a control, 3 propose a blocker; `ork` never promotes on its own):',
+        nenhuma: '  (no recurring rule yet)', item: (pack, rule, n, promotion, ids) => `  ${pack} ${rule}: ${n}x -> proposed promotion: ${promotion} (${ids})`,
+        resumo: (open, total) => `open: ${open} | total listed: ${total}`,
+        thread: 'Turn a finding into a thread with: ork thread new "<name>" --from-finding <ID>',
+    },
+    superficie: {
+        vazia: (detail) => `No attack-surface finding. ${detail}`,
+        cabecalho: ['RULE', 'SEVERITY', 'CONFIDENCE', 'FRAMEWORK', 'ROUTE', 'EVIDENCE', 'TITLE'],
+        titulo: 'Deterministic network attack-surface scan (security-privacy pack, SP8..SP12)',
+        campo: (name, value) => `  ${name.padEnd(13)} ${value}`,
+        campos: { raiz: 'root', escopo: 'scope', frameworks: 'frameworks', teto: 'limit' },
+        nenhumFramework: '(none recognized)', teto: (n) => `${n} finding(s) per rule`,
+        truncado: (n, rule) => `  WARNING: ${n} finding(s) for ${rule} exceeded this scan's limit.`,
+        baixa: (n, description) => `  ${n} finding(s) have low confidence: ${description}`,
+        claims: 'Each finding carries the command that reruns it at the real HEAD (the auditor cannot self-report).',
+        registrar: 'To record findings in a run debt board: ork audit surface --registrar <run>',
+    },
+    cli: {
+        packs: (list) => `  packs: ${list}`,
+        lintTitulo: (root) => `Audit template lint${root ? ` (project ${root})` : ' (embedded only)'}`,
+        lintItem: (severity, template, rule) => `  [${severity}] ${template} :: ${rule}`, lintDetalhe: (detail) => `           ${detail}`,
+        lintOk: (n) => `  no problem in ${n} template(s)`, lintResumo: (templates, errors, warnings) => `templates: ${templates} | errors: ${errors} | warnings: ${warnings}`,
+        bloqueada: (id) => `Audit run ${id} BLOCKED.`, motivo: (v) => `  typed reason: ${v}`, detalhe: (v) => `  detail: ${v}`,
+        estado: (id) => `  run state: .orkastery/audits/${id}/run.json`, ensaio: (id) => `Simulation (--dry-run) of run ${id}: nothing was dispatched.`,
+        despachada: (id, runtime) => `Audit run ${id} dispatched by runtime adapter ${runtime}.`,
+        verificada: (ok) => `  verified in runtime: ${ok ? 'yes' : 'NO (check `ork sessions`)'}`,
+        superficieDry: (id) => `              nothing recorded in the board (--dry-run). To write: ork audit surface --registrar ${id}`,
+        superficieBoard: (n, confirm) => `              ${n} surface finding(s) already in the debt board${confirm > 0 ? `, ${confirm} with low confidence (require human confirmation)` : ''}`,
+        proposta: 'The run ends in a PROPOSAL for the roadmap, never in an applied fix.', depois: (id) => `After the findings: ork audit verify ${id} && ork audit report ${id}`,
+        board: (summary) => `Debt board: ${summary}`, ingestao: (id, n) => `Run ${id} ingestion: ${n} finding(s) in the debt board.`,
+        memoriaMuitas: (detail) => `Memory (orkmind): proposals in the roadmap collection, ${detail}.`, memoriaUma: (detail) => `Memory (orkmind): proposal in the roadmap collection, ${detail}.`,
+        duplicados: (ids) => `Already recorded in this run and ignored (ingestion is idempotent): ${ids}`,
+        recusados: (n) => `REJECTED (${n}):`, recusado: (n, error) => `  finding #${n}: ${error}`, prove: (id) => `Prove the findings before any thread: ork audit verify ${id}`,
+        achadoRegistrado: (finding, run) => `Finding ${finding} recorded in the debt board for run ${run}.`,
+        estadoReservado: 'status `virou-thread` is stamped by `ork thread new --from-finding` itself.', achadoEstado: (id, status) => `Finding ${id} is now ${status}.`,
+        findingDesconhecido: (action) => `unknown subcommand: audit finding ${action}`,
+        verifyTitulo: (id) => `Claims for findings in run ${id}, rerun at the real HEAD.`, verifyHead: (head) => `  real HEAD   ${head}`, verifyDir: (cwd) => `  directory   ${cwd}`,
+        verifyVazio: '  (no open finding in this run)', verifyClaim: (id, ok, claim) => `  ${id}  verified: ${ok ? 'yes' : 'NO'}  ${claim}`,
+        arquivo: (v) => `      file: ${v}`, comandos: (v) => `      command(s): ${v}`, semComando: '      no verification command', motivoDetalhe: (m, d) => `      typed reason: ${m} (${d})`,
+        vereditoOk: 'Verdict: FINDINGS SUSTAINED (the auditor proved its claims).', vereditoRuim: (m) => `Verdict: FAILED. Typed reasons: ${m}`,
+        unverifiable: '  warning: a finding without a verification command warns and does not block (B1 gate rule).',
+        relatorio: (path) => `(report written to ${path})`, publicado: (path) => `(published to ${path})`,
+        rodadaRegistrada: (id, n) => `Run ${id}: ${n} finding(s) recorded in the debt board.`, jaRegistrados: (ids) => `  already recorded in this run: ${ids}`,
+        recusadoSuperficie: (rule, file, line, error) => `  REJECTED ${rule} ${file}:${line}: ${error}`,
+    },
+    uso: (sub) => usoDe({ run: 'usage: ork audit run <pack> [--profile P] [--since Nd]', show: 'usage: ork audit show <run> [--ledger]', prompt: 'usage: ork audit prompt <pack> [--since Nd]', ingest: 'usage: ork audit ingest <run> --arquivo <findings.json>', verify: 'usage: ork audit verify <run>', report: 'usage: ork audit report <run> [--publicar]' }, sub) ?? `unknown subcommand: audit ${sub}`,
+    erro: { estagio: (v) => `invalid stage: "${v}". Use: nascente | crescendo | maduro`, pack: (v, list) => `unknown pack: "${v}". Use one of: ${list}`, regra: (v, list) => `unknown rule: "${v}". Use one of: ${list}`, limite: (v) => `invalid --limite: "${v}". Use an integer >= 1.` },
+};

package/dist/locale-claims.js

@@ -0,0 +1,213 @@
+"use strict";
+/**
+ * RM-061, fatia F3b: a familia `claims` do catalogo de mensagens (`ork claims add|conferir|verificar|retirar|ausente|
+ * list`), a tabela das claims, o lint do comando de claim, as recusas da conferencia pontual e as da prova minima. O
+ * pt-BR e a fonte; o ingles e tipado por ele. Sem import do nucleo.
+ *
+ * A alegacao, o arquivo, o comando e o motivo digitado pelo dono sao dado e saem como vieram; o estado de uma claim
+ * (dado do `claims.jsonl`) e a regra do lint so se traduzem na impressao, pelo id. A correcao do lint que vai ao
+ * `claims.jsonl` sai sempre do pt-BR (`claim-lint.ts`). As recusas da conferencia saem no `--json` como nasceram (em
+ * pt-BR, porque o `--json` nunca ativa o locale) e o texto as remonta no locale do comando.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLAIMS_EN = exports.CLAIMS_PT_BR = void 0;
+/** O erro do executor do sandbox (`verify-sandbox.ts`), pela frase exata: o que nao casa sai como veio. */
+const ERROS_DO_SANDBOX_EN = [
+    [/^executor VERIFY sandbox disponível somente em Linux$/, () => 'the VERIFY sandbox executor is only available on Linux'],
+    [/^worktree deve ser absoluta$/, () => 'the worktree must be an absolute path'],
+    [/^worktree inválida$/, () => 'invalid worktree'],
+    [/^timeout sandbox fora do limite$/, () => 'sandbox timeout out of bounds'],
+    [/^executor sandbox fechado$/, () => 'sandbox executor closed'],
+    [/^escopo\/binário do executor sandbox mudou$/, () => 'the sandbox executor scope or binary changed'],
+    [/^scratch VERIFY deve ficar fora da worktree$/, () => 'the VERIFY scratch must stay outside the worktree'],
+    [/^cleanup incompleto: consumidores não comprovadamente encerrados; isolamento preservado: (.+)$/,
+        (dir) => `incomplete cleanup: consumers not proven closed; isolation kept: ${dir}`],
+    [/^cleanup incompleto: isolamento substituído; preservado$/, () => 'incomplete cleanup: isolation replaced; kept'],
+    [/^isolamento sandbox mudou$/, () => 'the sandbox isolation changed'],
+    [/^metadado protegido inesperado; objeto preservado: (.+)$/, (nome) => `unexpected protected metadata; object kept: ${nome}`],
+    [/^metadado temporário mudou antes do lançamento$/, () => 'temporary metadata changed before the launch'],
+    [/^identidade mudou$/, () => 'the identity changed'],
+    [/^scratch mudou$/, () => 'the scratch changed'],
+    [/^supervisor saiu (.+)$/, (status) => `supervisor exited ${status}`],
+    [/^resposta inválida$/, () => 'invalid answer'],
+];
+const ESTADOS_EN = {
+    pendente: 'pending', verificado: 'verified', reprovado: 'failed', 'nao-verificavel': 'unverifiable', retirada: 'withdrawn',
+};
+exports.CLAIMS_PT_BR = {
+    // ork claims add
+    usoAdd: 'uso: ork claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"]',
+    registrada: (id, thread) => `Claim ${id} registrada na thread ${thread}.`,
+    campoArquivo: (arquivo) => `  arquivo    ${arquivo}`,
+    campoAlegacao: (alegacao) => `  alegacao   ${alegacao}`,
+    campoNegativa: (negativa) => `  negativa   ${negativa ? 'sim (exige comando de verificacao)' : 'nao'}`,
+    campoVerificar: (verificar) => `  verificar  ${verificar || '(nenhum comando declarado)'}`,
+    campoEstado: (estado) => `  estado     ${estado}`,
+    campoMotivo: (motivo) => `  motivo     ${motivo}`,
+    /** O estado gravado no `claims.jsonl`, como o texto o mostra. */
+    estado: (estado) => estado,
+    avisoNegativa: 'AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.',
+    /** A linha do lint no `claims add` (no `ci prepare` o lint sai em pt-BR, como antes). */
+    avisoDoLint: (linha, suiteInteira) => `AVISO: ${linha}${suiteInteira ? '. O `ci prepare` recusa esta claim.' : ''}`,
+    linhaDoLint: (claim, nome, trecho, correcao) => `${claim} ${nome} (${trecho}); ${correcao}`,
+    nomesDoLint: { 'suite-inteira': 'roda a suite inteira', 'sha-intermediario': 'fixa um SHA intermediario',
+        'contagem-de-commits': 'compara contagem de commits' },
+    correcoesDoLint: {
+        'suite-inteira': 'rode só o teste da claim (`node --test` no arquivo do teste, ou o comando do projeto que roda um arquivo) ' +
+            'ou um script hermético do projeto',
+        'sha-intermediario': 'ancore na base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) ou prove ancestralidade com `git merge-base --is-ancestor <sha> HEAD`',
+        'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: contagem de commits quebra com rebase e merge',
+    },
+    // ork claims conferir
+    usoConferir: 'uso: ork claims conferir <thread-id> --claims C1,C2 | --tarefa T1 [--prazo S] [--json]',
+    conferencia: (thread) => `Conferencia pontual da thread ${thread} (sem recibo: o ork verify continua sendo quem verifica)`,
+    headReal: (commit) => `  HEAD real   ${commit}`,
+    executor: (executor, segundos) => `  executor    ${executor}, prazo total ${segundos} s`,
+    alvoClaims: (ids) => `  alvo        claims ${ids}`,
+    alvoTarefa: (tarefa, sha, comando) => `  alvo        verify da tarefa ${tarefa} (plano sha256 ${sha}): ${comando}`,
+    item: (id, verificado, motivo, alegacao) => `  ${id}  ${verificado ? 'passou' : `NAO PASSOU (${motivo})`}  ${alegacao}`,
+    tudoPassou: 'Resultado: tudo passou.',
+    naoPassou: (motivos) => `Resultado: nao passou. Motivos: ${motivos}`,
+    prazoEsgotado: 'nao executado: prazo total da conferencia esgotado',
+    /** As recusas tipadas da conferencia: `claims.conferir.<motivo>: <detalhe>`. */
+    recusa: (motivo, detalhe) => `claims.conferir.${motivo}: ${detalhe}`,
+    semClaims: 'informe ao menos uma claim em --claims (ex.: C3,C7)',
+    idInvalido: (id) => `id de claim invalido: ${id}`,
+    repetida: (id) => `${id} pedida duas vezes`,
+    tarefaInvalida: (tarefa) => `tarefa invalida: ${tarefa} (ex.: T2.1)`,
+    tarefaAusente: (tarefa) => `o plano nao tem a tarefa ${tarefa}`,
+    tarefaRepetida: (n, tarefa) => `o plano tem ${n} cabecalhos da tarefa ${tarefa}`,
+    tarefaSemVerify: (tarefa) => `a tarefa ${tarefa} nao tem linha de verify`,
+    tarefaAmbigua: (tarefa, n) => `a tarefa ${tarefa} tem ${n} linhas de verify`,
+    tarefaSemComando: (tarefa, resto) => `o verify da tarefa ${tarefa} nao tem comando entre crases: ${resto}`,
+    tarefaVariosTrechos: (tarefa, n, resto) => `o verify da tarefa ${tarefa} tem ${n} trecho(s) entre ` +
+        `crases e texto alem de um comando so (${resto}); a conferencia nao escolhe qual pedaco rodar`,
+    planoNaoAbre: 'docs/plan.md da thread nao abre como arquivo comum',
+    planoGrande: 'docs/plan.md da thread nao e arquivo comum de ate 128 KiB',
+    semWorktree: (thread) => `a thread ${thread} nao tem worktree propria; a conferencia so roda nela`,
+    worktreeAusente: (thread) => `a worktree da thread ${thread} nao existe no disco`,
+    worktreeFora: (thread) => `a worktree da thread ${thread} fica fora do projeto`,
+    worktreeNaoRegistrada: (thread, branch) => `a worktree da thread ${thread} nao esta registrada no git do projeto na branch ${branch}`,
+    sandboxIndisponivel: (erro) => `${erro}; a conferencia so roda confinada, sem fallback`,
+    /** O erro do executor do sandbox, que o `verify-sandbox.ts` escreve em pt-BR, como a recusa o mostra. */
+    erroDoSandbox: (erro) => erro,
+    /** A alegacao que a conferencia por tarefa monta para o `verify` do plano (vai ao `--json` em pt-BR). */
+    verifyDaTarefa: (tarefa) => `verify da tarefa ${tarefa} do plano`,
+    claimsOuTarefa: 'informe --claims C1,C2 ou --tarefa T1, um dos dois',
+    prazo: (minimo, maximo) => `--prazo vai de ${minimo} a ${maximo} segundos`,
+    threadAusente: (thread) => `a thread ${thread} nao existe neste projeto`,
+    threadFechada: (thread) => `a thread ${thread} esta fechada`,
+    desconhecida: (id, thread) => `${id} nao existe na thread ${thread}`,
+    retiradaNaConferencia: (id, motivo) => `${id} foi retirada (${motivo ?? 'sem motivo'})`,
+    planoAusente: (thread) => `a thread ${thread} nao tem docs/plan.md`,
+    // ork claims verificar, retirar, ausente e list
+    usoVerificar: 'uso: ork claims verificar <thread-id> <claim-id> --comando "<comando>"',
+    comandoAnexado: (id) => `Claim ${id} agora tem comando de verificacao.`,
+    proveAgora: (thread) => `Prove agora: ork verify ${thread}`,
+    usoRetirar: 'uso: ork claims retirar <thread-id> <claim-id> --motivo "<motivo>"',
+    retirada: (id, thread) => `Claim ${id} retirada da thread ${thread}.`,
+    historicoContinua: '  o historico da alegacao continua no claims.jsonl e no ledger.',
+    usoAusente: 'uso: ork claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]',
+    ausenciaRegistrada: (thread, paths) => `Ausencia de prova registrada na thread ${thread}: ${paths}.`,
+    usoList: 'uso: ork claims list <thread-id>',
+    // claims.ts
+    naoExiste: (id, thread) => `claim "${id}" nao existe na thread ${thread}`,
+    listaVazia: (thread) => `Nenhuma claim na thread ${thread}.\n` +
+        `Registre uma com: ork claims add ${thread} <arquivo> --claim "<alegacao>" --verificar "<comando>"`,
+    colunas: ['ID', 'FASE', 'ESTADO', 'NEGATIVA', 'ARQUIVO', 'VERIFICAR', 'ALEGACAO'],
+    sim: 'sim',
+    nao: 'nao',
+    semComando: '(sem comando)',
+    // prova-minima.ts
+    custoDeComandos: (limite, recebidos) => `claims.custo: ciclo sem CHECK aceita ate ${limite} comandos por claim ` +
+        `(recebidos ${recebidos}); use o teste focado ou declare a ausencia com ork claims ausente`,
+    custoDaSuite: (suite) => `claims.custo: ciclo sem CHECK nao roda a suite inteira ("${suite}"); ` +
+        'use o teste focado do arquivo que mudou',
+    ausenteSemMotivo: 'prova.ausente: o motivo e obrigatorio (uma linha)',
+    ausenteSemCaminhos: 'prova.ausente: informe os caminhos que ficaram sem prova',
+};
+exports.CLAIMS_EN = {
+    usoAdd: 'usage: ork claims add <thread-id> <file> --claim "<statement>" [--verificar "<command>"]',
+    registrada: (id, thread) => `Claim ${id} recorded in thread ${thread}.`,
+    campoArquivo: (arquivo) => `  file       ${arquivo}`,
+    campoAlegacao: (alegacao) => `  statement  ${alegacao}`,
+    campoNegativa: (negativa) => `  negative   ${negativa ? 'yes (needs a verification command)' : 'no'}`,
+    campoVerificar: (verificar) => `  verify     ${verificar || '(no command declared)'}`,
+    campoEstado: (estado) => `  state      ${estado}`,
+    campoMotivo: (motivo) => `  reason     ${motivo}`,
+    estado: (estado) => ESTADOS_EN[estado] ?? estado,
+    avisoNegativa: 'WARNING: a negative statement without a verification command fails in `ork verify`.',
+    avisoDoLint: (linha, suiteInteira) => `WARNING: ${linha}${suiteInteira ? '. `ci prepare` refuses this claim.' : ''}`,
+    linhaDoLint: (claim, nome, trecho, correcao) => `${claim} ${nome} (${trecho}); ${correcao}`,
+    nomesDoLint: { 'suite-inteira': 'runs the whole suite', 'sha-intermediario': 'pins an intermediate SHA',
+        'contagem-de-commits': 'compares a commit count' },
+    correcoesDoLint: {
+        'suite-inteira': 'run only the claim test (`node --test` on the test file, or the project command that runs one file) ' +
+            'or a hermetic project script',
+        'sha-intermediario': 'anchor on the base (`git diff "$(git merge-base origin/main HEAD)" HEAD`) or prove ancestry with `git merge-base --is-ancestor <sha> HEAD`',
+        'contagem-de-commits': 'use `git merge-base --is-ancestor <commit> HEAD`: a commit count breaks with rebase and merge',
+    },
+    usoConferir: 'usage: ork claims conferir <thread-id> --claims C1,C2 | --tarefa T1 [--prazo S] [--json]',
+    conferencia: (thread) => `Spot check of thread ${thread} (no receipt: \`ork verify\` is still what verifies)`,
+    headReal: (commit) => `  real HEAD   ${commit}`,
+    executor: (executor, segundos) => `  executor    ${executor}, total deadline ${segundos} s`,
+    alvoClaims: (ids) => `  target      claims ${ids}`,
+    alvoTarefa: (tarefa, sha, comando) => `  target      verify of task ${tarefa} (plan sha256 ${sha}): ${comando}`,
+    item: (id, verificado, motivo, alegacao) => `  ${id}  ${verificado ? 'passed' : `FAILED (${motivo})`}  ${alegacao}`,
+    tudoPassou: 'Result: everything passed.',
+    naoPassou: (motivos) => `Result: did not pass. Reasons: ${motivos}`,
+    prazoEsgotado: 'not run: the total deadline of the spot check ran out',
+    recusa: (motivo, detalhe) => `claims.conferir.${motivo}: ${detalhe}`,
+    semClaims: 'pass at least one claim in `--claims` (e.g. C3,C7)',
+    idInvalido: (id) => `invalid claim id: ${id}`,
+    repetida: (id) => `${id} requested twice`,
+    tarefaInvalida: (tarefa) => `invalid task: ${tarefa} (e.g. T2.1)`,
+    tarefaAusente: (tarefa) => `the plan has no task ${tarefa}`,
+    tarefaRepetida: (n, tarefa) => `the plan has ${n} headings for task ${tarefa}`,
+    tarefaSemVerify: (tarefa) => `task ${tarefa} has no verify line`,
+    tarefaAmbigua: (tarefa, n) => `task ${tarefa} has ${n} verify lines`,
+    tarefaSemComando: (tarefa, resto) => `the verify of task ${tarefa} has no command in backticks: ${resto}`,
+    tarefaVariosTrechos: (tarefa, n, resto) => `the verify of task ${tarefa} has ${n} backtick span(s) and text beyond a single ` +
+        `command (${resto}); the spot check does not pick which piece to run`,
+    planoNaoAbre: 'the thread `docs/plan.md` does not open as a regular file',
+    planoGrande: 'the thread `docs/plan.md` is not a regular file of up to 128 KiB',
+    semWorktree: (thread) => `thread ${thread} has no worktree of its own; the spot check only runs in it`,
+    worktreeAusente: (thread) => `the worktree of thread ${thread} does not exist on disk`,
+    worktreeFora: (thread) => `the worktree of thread ${thread} is outside the project`,
+    worktreeNaoRegistrada: (thread, branch) => `the worktree of thread ${thread} is not registered in the project git on branch ${branch}`,
+    sandboxIndisponivel: (erro) => `${erro}; the spot check only runs confined, with no fallback`,
+    erroDoSandbox: (erro) => {
+        const regra = ERROS_DO_SANDBOX_EN.find(([re]) => re.test(erro));
+        return regra ? regra[1](...(regra[0].exec(erro) ?? []).slice(1)) : erro;
+    },
+    verifyDaTarefa: (tarefa) => `the plan verify of task ${tarefa}`,
+    claimsOuTarefa: 'pass `--claims C1,C2` or `--tarefa T1`, one of the two',
+    prazo: (minimo, maximo) => `\`--prazo\` goes from ${minimo} to ${maximo} seconds`,
+    threadAusente: (thread) => `thread ${thread} does not exist in this project`,
+    threadFechada: (thread) => `thread ${thread} is closed`,
+    desconhecida: (id, thread) => `${id} does not exist in thread ${thread}`,
+    retiradaNaConferencia: (id, motivo) => `${id} was withdrawn (${motivo ?? 'no reason'})`,
+    planoAusente: (thread) => `thread ${thread} has no \`docs/plan.md\``,
+    usoVerificar: 'usage: ork claims verificar <thread-id> <claim-id> --comando "<command>"',
+    comandoAnexado: (id) => `Claim ${id} now has a verification command.`,
+    proveAgora: (thread) => `Prove it now: \`ork verify ${thread}\``,
+    usoRetirar: 'usage: ork claims retirar <thread-id> <claim-id> --motivo "<reason>"',
+    retirada: (id, thread) => `Claim ${id} withdrawn from thread ${thread}.`,
+    historicoContinua: '  the history of the statement stays in claims.jsonl and in the ledger.',
+    usoAusente: 'usage: ork claims ausente <thread-id> --paths A,B --motivo "<reason>" [--commit SHA]',
+    ausenciaRegistrada: (thread, paths) => `Missing proof recorded in thread ${thread}: ${paths}.`,
+    usoList: 'usage: ork claims list <thread-id>',
+    naoExiste: (id, thread) => `claim "${id}" does not exist in thread ${thread}`,
+    listaVazia: (thread) => `No claim in thread ${thread}.\n` +
+        `Record one with: ork claims add ${thread} <file> --claim "<statement>" --verificar "<command>"`,
+    colunas: ['ID', 'PHASE', 'STATE', 'NEGATIVE', 'FILE', 'VERIFY', 'STATEMENT'],
+    sim: 'yes',
+    nao: 'no',
+    semComando: '(no command)',
+    custoDeComandos: (limite, recebidos) => `claims.custo: a cycle without CHECK accepts up to ${limite} commands per claim ` +
+        `(got ${recebidos}); use the focused test or declare the gap with \`ork claims ausente\``,
+    custoDaSuite: (suite) => `claims.custo: a cycle without CHECK does not run the whole suite ("${suite}"); ` +
+        'use the focused test of the file that changed',
+    ausenteSemMotivo: 'prova.ausente: the reason is required (one line)',
+    ausenteSemCaminhos: 'prova.ausente: pass the paths that were left without proof',
+};

package/dist/locale-conducao.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONDUCAO_EN = exports.CONDUCAO_PT_BR = void 0;
+/** RM-061 F3d: texto humano de `ork conducao`; contratos e dados continuam inalterados. */
+exports.CONDUCAO_PT_BR = {
+    status: {
+        livre: (thread) => `Thread ${thread}: ninguem conduz agora. Qualquer canal pode despachar ou verificar.`,
+        titulo: (thread, linha) => `Thread ${thread}: ${linha}`,
+        prompt: (sha) => `  prompt sha256 ${sha}`,
+        prazo: (data) => `  prazo do lease (metadado, nao prova): ${data}`,
+        acompanhar: (sessao) => `  acompanhar: ork sessions logs ${sessao}`,
+        assumir: (thread) => `  assumir: ork conducao assumir ${thread} --por <voce> --motivo "<por que>"`,
+    },
+    recusa: {
+        esperar: 'Esperar a vez: repete este pedido e segue sozinho quando a conducao atual terminar (ate 30 min).',
+        acompanhar: 'Acompanhar quem conduz, sem mexer em nada.',
+        assumir: 'Assumir a conducao: encerra a atual pelo proprio runtime e registra no ledger quem assumiu, de qual canal e por que.',
+        titulo: (thread) => `Pedido nao executado: a thread ${thread} ja esta sendo conduzida agora, e duas execucoes na mesma worktree se corrompem (foi o que aconteceu em 19/09/2026).`,
+        quem: (canal, dono, fase, desde) => `  Quem conduz: canal ${canal}, ${dono}, fase ${fase}, desde ${desde}.`,
+        prompt: (sha) => `  Pedido em curso: prompt sha256 ${sha}.`,
+        entrando: '  Outra operacao esta tomando a conducao neste instante; o registro dela ainda nao apareceu.',
+        pedido: (operacao, fase, canal) => `  Pedido recusado: ${operacao}${fase ? ` da fase ${fase}` : ''}, pelo canal ${canal}.`,
+        opcoes: 'O que voce pode fazer:', passo: (n, explicacao) => `  ${n}. ${explicacao}`,
+        comandoAssumir: (thread) => `ork conducao assumir ${thread} --por <voce> --motivo "<por que>"`,
+    },
+    sentinela: {
+        desligada: (maquina) => `Sentinela: desligada na maquina ${maquina}; o condutor externo conduz.`,
+        ligada: (maquina, canal, sessao) => `Sentinela: ligada na maquina ${maquina}, canal ${canal}, sessao ${sessao}; o condutor externo cede o despacho e o retry, menos a retomada por cota.`,
+        vencida: (sessao) => `Sentinela: a presenca da sessao ${sessao} venceu; o condutor externo conduz.`,
+        nenhuma: '  nenhuma thread aberta neste checkout', despachar: (fase) => `despachar ${fase}`,
+    },
+    autorizacao: {
+        sem: (motivo, detalhe) => `Sem autorização durável válida nesta máquina (${motivo}): ${detalhe}.`,
+        semEfeito: '  A batida da condução não age sozinha: cada ação vira item da fila do pulse, com o comando pronto.',
+        autorizar: '  Para autorizar: ork conducao autorizar --ate <data> --pode merge,registrar,master,despachar [--por <seu nome>]',
+        valida: (por, ate, pode) => `Autorização durável de ${por} até ${ate}: a condução pode ${pode}.`,
+        concedida: (em, maquina, projeto, nota) => `  concedida em ${em} na máquina ${maquina}, projeto ${projeto}${nota ? `; nota: ${nota}` : ''}`,
+        arquivo: (arquivo, sha) => `  arquivo ${arquivo} (sha256 ${sha})`,
+        limite: '  Tag e publicação nunca entram. O prazo é do dono: depois dele, nada é feito sozinho.',
+        linhaValida: (por, ate, pode) => `autorização durável de ${por} até ${ate}: a varredura pode ${pode}`,
+        linhaAusente: 'sem autorização durável: as ações da varredura viram itens da fila do pulse, com o comando pronto',
+        linhaInvalida: (motivo, detalhe) => `autorização durável sem valor (${motivo}: ${detalhe}); as ações da varredura viram itens da fila do pulse`,
+    },
+    batida: {
+        ocupada: (detalhe) => `Outra batida da condução está agindo nesta máquina agora (${detalhe}); o resultado dela sai no próximo resumo.`,
+        autorizada: (por, ate, pode) => `Autorização durável de ${por} até ${ate}: a condução pode ${pode}.`,
+        semAutorizacao: (motivo) => `Sem autorização durável válida (${motivo}): nada foi feito sozinho; o que andaria ficou com você.`,
+        sentinela: 'A Sentinela conduz as fases nesta máquina agora; a batida manteve apenas a reação a cota.',
+        prs: (detalhe) => `PRs não lidos: ${detalhe}.`, base: (detalhe) => `Base não trazida: ${detalhe}.`,
+        voltou: (n) => `Voltou a andar: ${n}`, nada: 'Nada voltou a andar nesta batida.',
+        espera: (n) => `Espera a próxima batida: ${n}`, comVoce: (n) => `Com você: ${n}`,
+        item: (thread, acao, pr, detalhe) => `  ${thread}: ${acao}${pr ? ` do PR #${pr}` : ''}; ${detalhe}`,
+        itemDono: (thread, acao, pr, motivo, detalhe, comando) => `  ${thread}: ${acao}${pr ? ` do PR #${pr}` : ''} (${motivo}); ${detalhe}. Responder: ${comando}`,
+    },
+    atualizacao: {
+        atualizada: (branch, base, enviada) => `${branch} já contém ${base}: nada a mesclar${enviada ? '; a branch foi empurrada e conferida no remoto' : ''}.`,
+        mesclada: (base, branch, sha, devolvidos, enviada) => `${base} mesclada na ${branch} (${sha})${devolvidos ? `; ${devolvidos} item(ns) da thread de volta a "## Não publicado" do CHANGELOG` : ''}${enviada ? '; branch empurrada e conferida no remoto' : ''}.`,
+        conflito: (base, branch, arquivos) => `o merge de ${base} na ${branch} conflita em código (${arquivos}): abortado, e a resolução fica com o dono.`,
+        recusada: (branch, motivo, detalhe) => `atualização da ${branch} recusada (${motivo}): ${detalhe}.`,
+    },
+    cli: {
+        sentinelaUso: 'uso: ork conducao sentinela status|bater|desligar [--sessao <id>] [--json]', sentinelaSessao: (acao) => `uso: ork conducao sentinela ${acao} --sessao <id> [--json]`,
+        sentinelaLigada: (ligou, maquina, sessao) => `Sentinela ${ligou ? 'ligada' : 'renovada'} na maquina ${maquina} pela sessao ${sessao}; vale 3 min sem batida.`,
+        sentinelaOutra: (sessao, maquina) => `Outra sessao (${sessao}) conduz pela Sentinela na maquina ${maquina}; esta fica so olhando.`,
+        sentinelaOff: 'Sentinela desligada nesta maquina; o condutor externo volta a conduzir.', sentinelaNada: 'Nada a desligar: a presenca nesta maquina nao e desta sessao.',
+        autorizacaoUso: 'uso: ork conducao autorizacao [--json]', autorizarUso: 'uso: ork conducao autorizar --ate <data> --pode merge,registrar,master,despachar [--por Q] [--nota N] [--json]',
+        autorizacaoRecusada: (motivo, detalhe) => `Autorização recusada (${motivo}): ${detalhe}`, autorizacaoGravada: (linha) => `Autorização gravada. ${linha}.`,
+        substitui: (por, ate, pode) => `  substitui a de ${por} até ${ate} (${pode})`, arquivo: (arquivo) => `  arquivo ${arquivo}, fora do git; para revogar, apague o arquivo.`,
+        batidaUso: 'uso: ork conducao batida [--entregar] [--json]', pulseAviso: 'aviso: o transporte do pulse não confirmou a retomada (veja ork doctor)', pulseFalha: (erro) => `aviso: retomada sem transporte do pulse (${erro})`,
+        atualizarUso: 'uso: ork conducao atualizar <thread-id> [--enviar] [--esperar [min]] [--json]', statusUso: 'uso: ork conducao status <thread-id> [--json]',
+        assumirUso: 'uso: ork conducao assumir <thread-id> --por <quem> --motivo "<por que>" [--canal C]', assumida: (ok, detalhe) => `${ok ? 'Conducao assumida.' : 'Handoff recusado.'} ${detalhe}`,
+        detalheAssumida: (por, canal, ate) => `conducao assumida por ${por} pelo canal ${canal}; a proxima operacao desse canal usa a reserva ate ${ate}`,
+        uso: 'uso: ork conducao status|assumir|atualizar <thread-id> | ork conducao autorizar|autorizacao|batida | ork conducao sentinela status|bater|desligar',
+    },
+};
+exports.CONDUCAO_EN = {
+    status: {
+        livre: (thread) => `Thread ${thread}: nobody is conducting it now. Any channel may dispatch or verify.`, titulo: (thread, line) => `Thread ${thread}: ${line}`,
+        prompt: (sha) => `  prompt sha256 ${sha}`, prazo: (date) => `  lease deadline (metadata, not proof): ${date}`, acompanhar: (session) => `  follow: ork sessions logs ${session}`,
+        assumir: (thread) => `  take over: ork conducao assumir ${thread} --por <you> --motivo "<why>"`,
+    },
+    recusa: {
+        esperar: 'Wait your turn: the command below repeats this request and proceeds on its own once the current conduction ends (waiting up to 30 min).',
+        acompanhar: 'Follow who is conducting, without changing anything.',
+        assumir: 'Take over conduction: ends the current one through its own runtime and records in the ledger who took over, from which channel, and why.',
+        titulo: (thread) => `Request not executed: thread ${thread} is already being conducted, and two executions in the same worktree corrupt each other (as happened on 2026-09-19).`,
+        quem: (channel, owner, phase, since) => `  Conducted by: channel ${channel}, ${owner}, phase ${phase}, since ${since}.`,
+        prompt: (sha) => `  Request in progress: prompt sha256 ${sha}.`,
+        entrando: '  Another operation is taking conduction at this moment; its record has not appeared yet.',
+        pedido: (operation, phase, channel) => `  Rejected request: ${operation}${phase ? ` for phase ${phase}` : ''}, through channel ${channel}.`,
+        opcoes: 'What you can do:', passo: (n, explanation) => `  ${n}. ${explanation}`,
+        comandoAssumir: (thread) => `ork conducao assumir ${thread} --por <you> --motivo "<why>"`,
+    },
+    sentinela: {
+        desligada: (machine) => `Sentinel: off on machine ${machine}; the external conductor is active.`,
+        ligada: (machine, channel, session) => `Sentinel: on at machine ${machine}, channel ${channel}, session ${session}; the external conductor yields dispatch and retry, except quota recovery.`,
+        vencida: (session) => `Sentinel: the presence of session ${session} expired; the external conductor is active.`, nenhuma: '  no open thread in this checkout', despachar: (phase) => `dispatch ${phase}`,
+    },
+    autorizacao: {
+        sem: (reason, detail) => `No valid durable authorization on this machine (${reason}): ${detail}.`,
+        semEfeito: '  The conduction heartbeat does not act on its own: each action becomes a pulse queue item with a ready command.',
+        autorizar: '  To authorize: ork conducao autorizar --ate <date> --pode merge,registrar,master,despachar [--por <your name>]',
+        valida: (by, until, allowed) => `Durable authorization by ${by} until ${until}: conduction may ${allowed}.`,
+        concedida: (at, machine, project, note) => `  granted at ${at} on machine ${machine}, project ${project}${note ? `; note: ${note}` : ''}`,
+        arquivo: (file, sha) => `  file ${file} (sha256 ${sha})`, limite: '  Tags and publication are never included. The deadline belongs to the owner: after it, nothing is done automatically.',
+        linhaValida: (by, until, allowed) => `durable authorization by ${by} until ${until}: the sweep may ${allowed}`,
+        linhaAusente: 'no durable authorization: sweep actions become pulse queue items with a ready command',
+        linhaInvalida: (reason, detail) => `invalid durable authorization (${reason}: ${detail}); sweep actions become pulse queue items`,
+    },
+    batida: {
+        ocupada: (detail) => `Another conduction heartbeat is acting on this machine now (${detail}); its result will appear in the next summary.`,
+        autorizada: (by, until, allowed) => `Durable authorization by ${by} until ${until}: conduction may ${allowed}.`,
+        semAutorizacao: (reason) => `No valid durable authorization (${reason}): nothing was done automatically; work that could advance stayed with you.`,
+        sentinela: 'The Sentinel is conducting phases on this machine now; the heartbeat kept only quota reaction.', prs: (detail) => `PRs not read: ${detail}.`, base: (detail) => `Base not brought in: ${detail}.`,
+        voltou: (n) => `Advanced again: ${n}`, nada: 'Nothing advanced again in this heartbeat.', espera: (n) => `Waits for the next heartbeat: ${n}`, comVoce: (n) => `With you: ${n}`,
+        item: (thread, action, pr, detail) => `  ${thread}: ${action}${pr ? ` from PR #${pr}` : ''}; ${detail}`,
+        itemDono: (thread, action, pr, reason, detail, command) => `  ${thread}: ${action}${pr ? ` from PR #${pr}` : ''} (${reason}); ${detail}. Reply: ${command}`,
+    },
+    atualizacao: {
+        atualizada: (branch, base, pushed) => `${branch} already contains ${base}: nothing to merge${pushed ? '; the branch was pushed and verified on the remote' : ''}.`,
+        mesclada: (base, branch, sha, returned, pushed) => `${base} merged into ${branch} (${sha})${returned ? `; ${returned} thread item(s) returned to "## Não publicado" in CHANGELOG` : ''}${pushed ? '; branch pushed and verified on the remote' : ''}.`,
+        conflito: (base, branch, files) => `the merge of ${base} into ${branch} conflicts in code (${files}): aborted; resolution stays with the owner.`, recusada: (branch, reason, detail) => `update of ${branch} rejected (${reason}): ${detail}.`,
+    },
+    cli: {
+        sentinelaUso: 'usage: ork conducao sentinela status|bater|desligar [--sessao <id>] [--json]', sentinelaSessao: (action) => `usage: ork conducao sentinela ${action} --sessao <id> [--json]`,
+        sentinelaLigada: (started, machine, session) => `Sentinel ${started ? 'started' : 'renewed'} on machine ${machine} by session ${session}; valid for 3 min without a heartbeat.`,
+        sentinelaOutra: (session, machine) => `Another session (${session}) conducts through the Sentinel on machine ${machine}; this one only observes.`,
+        sentinelaOff: 'Sentinel turned off on this machine; the external conductor resumes.', sentinelaNada: 'Nothing to turn off: the presence on this machine does not belong to this session.',
+        autorizacaoUso: 'usage: ork conducao autorizacao [--json]', autorizarUso: 'usage: ork conducao autorizar --ate <date> --pode merge,registrar,master,despachar [--por Q] [--nota N] [--json]',
+        autorizacaoRecusada: (reason, detail) => `Authorization rejected (${reason}): ${detail}`, autorizacaoGravada: (line) => `Authorization stored. ${line}.`,
+        substitui: (by, until, allowed) => `  replaces the one from ${by} until ${until} (${allowed})`, arquivo: (file) => `  file ${file}, outside git; delete the file to revoke it.`,
+        batidaUso: 'usage: ork conducao batida [--entregar] [--json]', pulseAviso: 'warning: the pulse transport did not confirm recovery (see ork doctor)', pulseFalha: (error) => `warning: recovery without pulse transport (${error})`,
+        atualizarUso: 'usage: ork conducao atualizar <thread-id> [--enviar] [--esperar [min]] [--json]', statusUso: 'usage: ork conducao status <thread-id> [--json]',
+        assumirUso: 'usage: ork conducao assumir <thread-id> --por <who> --motivo "<why>" [--canal C]', assumida: (ok, detail) => `${ok ? 'Conduction taken over.' : 'Handoff rejected.'} ${detail}`,
+        detalheAssumida: (by, channel, until) => `conduction taken over by ${by} through channel ${channel}; the next operation from that channel uses the reservation until ${until}`,
+        uso: 'usage: ork conducao status|assumir|atualizar <thread-id> | ork conducao autorizar|autorizacao|batida | ork conducao sentinela status|bater|desligar',
+    },
+};