@orkastery/cli 0.5.6 → 0.6.0

package/dist/locale-operacao-restante.js

@@ -0,0 +1,931 @@
+"use strict";
+/**
+ * RM-061, F3d: mensagens das familias operacionais que ainda estavam fora do catalogo.
+ *
+ * Os valores vindos do runtime, do ledger ou de outro processo continuam dados: este
+ * catalogo traduz somente a moldura que o CLI monta para uma pessoa.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPERACAO_RESTANTE_EN = exports.OPERACAO_RESTANTE_PT_BR = void 0;
+exports.OPERACAO_RESTANTE_PT_BR = {
+    sessions: {
+        atencao: (valor) => `--atencao espera minutos (inteiro >= 0), recebeu "${valor}"`,
+        usoWatch: 'uso: ork sessions watch --thread T [--sessao ID] [--once]',
+        sessaoDaThread: 'sessão não pertence à thread',
+        usoEvent: 'uso: ork sessions event --tipo <tipo> --sessao <id> < payload.json (máximo 16384 bytes)',
+        eventoRecusado: (detalhe) => `evento recusado: ${detalhe}`,
+        exigeProjeto: 'ork sessions limpar-fantasmas precisa de um projeto (orkastery.yaml)',
+        request: 'sessions request exige thread, UUID, --fase e --runtime; --pergunta só confere o conteúdo nativo',
+        answer: 'sessions answer exige thread, pedido e envelope autenticado em --stdin',
+        reconcile: 'sessions reconcile exige thread e pedido',
+        supersede: 'sessions supersede exige thread, UUID, --fase e --runtime',
+        usoSub: (sub) => `uso: ork sessions ${sub} <sessao>`,
+        desconhecido: (sub) => `subcomando desconhecido: sessions ${sub}`,
+        inventario: {
+            abertura: (global, usuario, historico) => `Inventário ${global ? 'global' : 'do projeto'} da conta ${usuario}; histórico: ${historico ? 'incluído' : 'omitido'}.`,
+            fontes: (valor) => `Fontes: ${valor}`,
+            fonteEstado: { ausente: 'ausente', ok: 'ok', falha: 'FALHA' },
+            resumo: (total, semThread, ambiguas, fantasmas, ok) => `Total: ${total}; sem thread: ${semThread}; ambíguas: ${ambiguas}; fantasmas: ${fantasmas}; consulta: ${ok ? 'válida' : 'INCOMPLETA'}.`,
+            colunas: ['ID', 'RUNTIME', 'PERFIL', 'ESTADO', 'THREAD/FASE'],
+            processo: 'processo', desconhecido: 'unknown', fantasma: 'fantasma', fora: '(fora do ork)',
+            explicacaoFantasma: 'Fantasma: registro sem processo vivo, não ocupa vaga; `ork sessions limpar-fantasmas` solta o vínculo do ork sem tocar no runtime.',
+            falha: (detalhe) => `Falha: ${detalhe}`,
+            ausente: (detalhe, correcao) => `Ausente: ${detalhe}${correcao ? `; correção: ${correcao}` : ''}`,
+        },
+        localizar: {
+            ambigua: (chave, contas) => `sessao "${chave}" encontrada em mais de uma conta: ${contas}; use o id completo`,
+            ausente: (chave, falhas) => `sessao "${chave}" nao encontrada no runtime${falhas ? `; contas sem resposta: ${falhas}` : ''}`,
+            parada: (id, perfil) => `sessao ${id} parada${perfil ? ` (perfil ${perfil})` : ''}`,
+        },
+        limpeza: {
+            nenhuma: (parcial) => `Nenhuma sessão fantasma${parcial ? ' nas contas que responderam' : ''}.`,
+            falha: (detalhe) => `Falha: ${detalhe}`,
+            acoes: {
+                soltaria: 'soltaria (sessao_morta no ledger)', solto: 'solto: sessao_morta no ledger',
+                jaSolto: 'já encerrada no ledger', semThread: 'fora do ork: nada a soltar',
+                outroProjeto: 'vínculo de outro projeto: rode lá',
+            },
+            abertura: (ensaio) => `Sessões fantasma (sem pid e sem processo)${ensaio ? ', ensaio: nada foi gravado' : ''}. O runtime não foi tocado.`,
+            colunas: ['ID', 'PERFIL', 'THREAD/FASE', 'AÇÃO'],
+            processo: 'processo',
+        },
+        radar: {
+            titulo: (total) => `Radar de sessoes do runtime (${total} sessao(oes) na maquina)`,
+            resumo: (humanas, hitl, abandonadas, falhas, desconhecidas, trabalhando, fora) => `  precisam de humano: ${humanas} (HITL vivo ${hitl}, abandonada ${abandonadas}, falha ${falhas}, ` +
+                `estado desconhecido ${desconhecidas}) | trabalhando: ${trabalhando} | fora do ork: ${fora}`,
+            limite: (minutos, acima) => `  limite de atencao: ${minutos} min (${acima} parada(s) acima, marcadas com !)`,
+            falha: (detalhe) => `  [fail] ${detalhe}: NAO da para saber quem esta parado`,
+            semLogs: '  [warn] --sem-logs: o radar diz QUEM esta parado, mas nao O QUE cada sessao pergunta',
+            nenhuma: '  Nenhuma sessao na varredura.',
+            colunas: ['ID', 'NOME', 'CLASSE', 'ESTADO', 'TIPO', 'DIRETORIO', 'THREAD', 'IDADE'],
+            vazio: '(vazio)', fora: 'fora do ork', nenhumaEsperando: '  Nenhuma sessao esperando o humano.',
+            vivas: 'Esperando o HUMANO agora, com o job VIVO (responder destrava na hora):',
+            mortas: 'MORRERAM esperando resposta (job ja saiu: nao adianta responder, o trabalho parou):',
+            onde: 'onde', porque: 'por que', pergunta: 'pergunta', log: 'log', opcao: 'opcao',
+            parada: 'parada ha', viva: 'viva ha', ver: 'ver', responder: 'responder', recomendo: 'recomendo',
+            thread: (id, fase) => `thread ${id}, fase ${fase}`,
+            sessaoFora: 'sessao fora do ork',
+            paradaDesconhecida: 'desconhecido; registre com --registrar',
+            desdeObservacao: 'desde a primeira observação', idade: 'idade da sessao', desdeInicio: 'desde que a sessao comecou',
+        },
+    },
+    gate: {
+        usoContext: 'uso: ork gate context <thread> <pedido> [--native-offer-stdin]',
+        requestThread: 'gate request exige thread',
+        formato: 'gate request: --formato telegram|terminal',
+        answer: 'gate answer exige thread, pedido e --resposta-stdin',
+        usoNext: 'uso: ork gate next <thread-id> [--proximo FASE] [--ocupacao 0..1]',
+        approveAposentado: 'gate approve aposentado: aprovação sem pedido é recusada. Use ork gate request <thread-id> e responda pelo ingresso humano autenticado.',
+        registrado: (thread) => `Autorizacao humana registrada no ledger da thread ${thread}.`,
+        sobre: (valor) => `  sobre          ${valor}`,
+        autorizado: (valor) => `  autorizado por ${valor}`,
+        quando: (valor) => `  quando         ${valor}`,
+        desconhecido: (sub) => `subcomando desconhecido: gate ${sub}`,
+        tokens: {
+            titulo: (thread) => `ork gate next: thread ${thread}`,
+            ocupacao: (valor) => `  ocupacao       ${valor}`,
+            naoMedivel: 'nao medivel',
+            fonte: (valor) => `  fonte          ${valor}`,
+            detalhe: (valor) => `                 ${valor}`,
+            limiares: (rotate, force) => `  limiares       rotate_above ${rotate} | force_rotate_above ${force}`,
+            proximo: (fase, peso) => `  proximo passo  ${fase} (${peso})`,
+            pesado: 'pesado', leve: 'leve',
+            veredito: (valor, fonte) => `VEREDITO: ${valor}  (decidido por ${fonte})`,
+            razao: (valor) => `  razao: ${valor}`,
+            slug: (valor) => `  slug da nova sessao: ${valor}`,
+            handoff: (thread, fase) => `  proximo passo: ork handoff export ${thread} --proxima-fase ${fase}`,
+            ledger: (thread) => `Registrado no ledger como token_gate: ork phase list ${thread}`,
+            localizarDetalhe: (_fonte, valor) => valor,
+            localizarRazao: (_ocupacao, _rotate, _force, _pesado, _refazer, _proximo, valor) => valor,
+        },
+    },
+    fix: {
+        usoOpen: 'uso: ork fix open <thread-id> [--so-claims] [--reverify]',
+        usoList: 'uso: ork fix list <thread-id> [--rodada N]',
+        semRodada: (thread) => `A thread ${thread} nao tem rodada de GO-FIX. Abra com: ork fix open ${thread}`,
+        lista: (rodada, thread) => `Correcoes da rodada ${rodada} da thread ${thread}`,
+        colunasLista: ['ID', 'TIPO', 'MOTIVO', 'ALVO', 'ESTADO', 'JULGADO POR'],
+        usoReverify: 'uso: ork fix reverify <thread-id> [--rodada N] [--parcial]',
+        desconhecido: (sub) => `subcomando desconhecido: fix ${sub}`,
+        semCorrecoes: (thread) => `Thread ${thread}: o CHECK PASSOU no HEAD real, nao ha correcao a abrir.\n` +
+            '  (nenhum motivo tipado bloqueante em `ork verify`)',
+        aberto: (thread, rodada) => `GO-FIX aberto na thread ${thread} (rodada ${rodada})`,
+        veredito: (valor) => `  veredito do CHECK   ${valor}`,
+        motivos: (valor) => `  motivos tipados     ${valor}`,
+        reexecucao: (tipoB) => `  reexecucao          ${tipoB ? 'COMPLETA obrigatoria (ha correcao tipo B)' : 'parcial permitida (rodada so de tipo A)'}`,
+        colunas: ['ID', 'TIPO', 'MOTIVO', 'ALVO', 'JULGADO POR'],
+        verifyCompleto: '(verify completo)',
+        spec: 'Spec exata despachada ao GO-FIX:',
+        reverify: (thread, rodada) => `CHECK-REVERIFY da thread ${thread} (rodada ${rodada})`,
+        cobertura: (valor) => `  cobertura   ${valor}`,
+        rodadas: (rodadas, limite) => `  rodadas     ${rodadas} de ${limite} antes da escalacao`,
+        porCorrecao: 'Veredito por correcao:',
+        correcao: (id, tipo, aprovada, alvo) => `  ${id}  tipo ${tipo}  ${aprovada ? 'APROVADA' : 'REPROVADA'}  ${alvo}`,
+        origem: (valor) => `      motivo de origem: ${valor}`,
+        execucao: (ok, comando) => `      ${ok ? 'ok  ' : 'FALHOU'} ${comando}`,
+        verify: (commit, ok, motivos) => `Verify completo no HEAD ${commit}: ${ok ? 'verde' : `reprovado (${motivos})`}`,
+        final: (valor) => `Veredito final: ${valor}`,
+        escalado: '  ESCALADO PARA HUMANO: esta pausa vale em qualquer modo, inclusive #Auto.',
+        vereditos: { PASSOU: 'PASSOU', 'PRECISA DE MUDANCA': 'PRECISA DE MUDANCA', BLOQUEADO: 'BLOQUEADO' },
+        coberturas: { completa: 'completa', parcial: 'parcial' },
+    },
+    handoff: {
+        usoExport: 'uso: ork handoff export <thread-id> [--proxima-fase FASE]',
+        historico: (caminho) => `Historico: ${caminho}`,
+        usoRecall: 'uso: ork handoff recall <thread-id> <path#ancora>',
+        resolvido: (local) => `Ponteiro resolvido: ${local}`,
+        metodo: (valor) => `  metodo       ${valor}`,
+        sha: (valor) => `  sha256       ${valor}`,
+        linhas: (valor) => `  linhas       ${valor}`,
+        naoAplicavel: '(nao aplicavel)',
+        desconhecido: (sub) => `subcomando desconhecido: handoff ${sub}`,
+        exportado: (thread, memory) => `Handoff exportado da thread ${thread} (regime memory: ${memory})`,
+        de: (slug, fase) => `  de    ${slug} (fase ${fase})`,
+        para: (slug, fase) => `  para  ${slug} (fase ${fase})`,
+        arquivo: (caminho) => `  arquivo ${caminho}`,
+        critico: (total) => `CRITICO (${total} item(ns), vao inline no prompt da nova sessao):`,
+        proveniencia: (local, sha) => `        proveniencia: ${local} (sha256 ${sha})`,
+        importante: (total) => `IMPORTANTE (${total} ponteiro(s), recuperados sob demanda):`,
+        quando: (valor) => `        quando:   ${valor}`,
+        recuperar: (valor) => `        recuperar: ${valor}`,
+        noMomento: (thread, quando) => `        no momento: ork recall ${thread} --fase ${quando}`,
+        resumivel: (total) => `RESUMIVEL (${total} resumo(s), com proveniencia declarada):`,
+    },
+    recall: {
+        uso: 'uso: ork recall <thread-id> [--fase FASE] [--id ptr-N] [--todos] [--forcar]',
+        titulo: (thread, momento, regime, handoff) => `Recall da thread ${thread} no momento ${momento} (regime efetivo ${regime}, handoff escrito em regime ${handoff})`,
+        todos: '(todos)',
+        resolvidos: (total) => `RESOLVIDOS (${total}, entram no contexto agora):`,
+        via: (via, metodo) => `        via       ${via} (${metodo})`,
+        location: (valor) => `        location  ${valor}`,
+        quando: (valor) => `        quando    ${valor}`,
+        adiados: (total) => `ADIADOS (${total}, existem e NAO entram agora):`,
+        onde: (valor) => `        onde      ${valor}`,
+        recuperar: (thread, fase) => `        recuperar ork recall ${thread} --fase ${fase}`,
+        falhas: (total) => `FALHAS (${total}):`,
+        motivo: (valor) => `        motivo    ${valor}`,
+        detalhe: (valor) => `        detalhe   ${valor}`,
+    },
+    lease: {
+        titulo: 'Leases do projeto',
+        nenhum: '  Nenhum lease tomado. O merge na base esta liberado.',
+        situacao: { vencido: 'VENCIDO (tomavel)', ativo: 'ativo' },
+        item: (nome, tipo, thread, situacao) => `  ${nome.padEnd(28)} [${tipo}] thread ${thread.padEnd(18)} ${situacao}`,
+        periodo: (desde, ate, pid) => `    desde ${desde} ate ${ate} (pid ${pid})`,
+        motivo: (valor) => `    motivo: ${valor}`,
+        legado: (local) => `    legado: ${local} (vale enquanto vivo, dentro da janela de 30 min da troca)`,
+        legadoInvalido: (arquivo) => `  legado: ${arquivo} INVALIDO ou ILEGIVEL (ignorado)`,
+        legadoPreservado: '    arquivo legado preservado; ignorado sem alterar o lease canonico',
+        filaRetomada: (total) => `Fila de retomada: ${total === 0 ? 'vazia' : `${total} lease(s)`}`,
+        candidato: (nome, pid, ticket, idade) => `    ${nome} pid ${pid} ${ticket === null ? 'temporario' : `ticket ${ticket}`} idade ${idade}s`,
+        prazo: '      lease.resume-unavailable: prazo de 30 min excedido; repita a aquisicao para recolher e consulte ork lease list',
+        filaInsegura: '    lease.resume-unavailable: fila ilegivel ou insegura; inspecione candidatos antes de repetir a aquisicao',
+        filaMerge: (total) => `Fila de merge (lease main-tree): ${total === 0 ? 'vazia' : `${total} na espera`}`,
+        esperaMerge: (n, thread, desde, por) => `  ${n}. thread ${thread} desde ${desde} (bloqueada por ${por})`,
+        filaRegiao: (total) => `Fila por colisao de regiao: ${total === 0 ? 'vazia' : `${total} na espera`}`,
+        esperaRegiao: (n, thread, nome, colide, por, desde) => `  ${n}. thread ${thread} quer ${nome}, colide com ${colide} (thread ${por}) desde ${desde}`,
+        semMotivo: 'sem motivo declarado',
+        usoAcquire: 'uso: ork lease acquire <nome> --thread <thread-id> [--motivo "<motivo>"]',
+        adquirido: (nome, tipo, thread) => `Lease ${nome} [${tipo}] adquirido pela thread ${thread}.`,
+        expira: (valor) => `  expira em ${valor}`,
+        tomado: '  (o lease anterior estava VENCIDO e foi tomado)',
+        naoAdquirido: (nome) => `Lease ${nome} NAO adquirido.`,
+        motivoTipado: (valor) => `  motivo tipado: ${valor}`,
+        detalhe: (valor) => `  detalhe: ${valor}`,
+        posicao: (valor) => `  posicao na fila: ${valor}`,
+        correcao: (valor) => `  correcao: ${valor}`,
+        usoRelease: 'uso: ork lease release <nome> [--thread <thread-id>] [--forcar]',
+        desconhecido: (sub) => `subcomando desconhecido: lease ${sub}`,
+    },
+    board: {
+        reapVazio: 'Nenhuma vaga a devolver: toda thread aberta tem procura ativa ou esta pronta para rodar.',
+        reapTitulo: (total, fuso) => `Vagas devolvidas por falta de procura ativa: ${total}. ${fuso}`,
+        reapMarca: { gravada: 'slot_released gravado no ledger', anterior: 'ja registrado antes (idempotente)' },
+        detalhe: (valor) => `    detalhe  : ${valor}`,
+        evidencia: (valor) => `    evidencia: ${valor}`,
+        filaItem: (n, thread, nome, colide, por, desde) => `  ${n}. ${thread} quer ${nome} (colide com ${colide}, thread ${por}) desde ${desde}`,
+        planoTitulo: (fuso) => `Escalonador por maquina. ${fuso}`,
+        limite: (max, andamento) => `  limite de paralelismo: ${max} (concurrency.max_parallel_threads) | ` +
+            `em andamento agora (procura ativa): ${andamento}`,
+        nenhumaThread: '  Nenhuma thread no projeto.',
+        colunasPlano: ['THREAD', 'SLUG', 'MODO', 'FASE', 'SITUACAO', 'MOTIVO', 'DETALHE'],
+        correcoes: '  Correcoes acionaveis:',
+        merge: 'Merge queue (lease main-tree, o unico gate de merge)',
+        mergeVazia: '  vazia: nenhuma thread esperando para mergear',
+        regiao: 'Fila por colisao de regiao',
+        regiaoVazia: '  vazia: nenhuma colisao de path, board ou porta',
+        titulo: (projeto, threads, perfis, nomes) => `Board do Orkastery, projeto ${projeto} (${threads} thread(s) em ${perfis} perfil(is): ${nomes})`,
+        vazio: '  Nenhuma thread ainda. Crie uma com: ork thread new "<nome>" --modo default',
+        colunas: ['PERFIL', 'ID', 'SLUG', 'MODO', 'FASE', 'STATUS', 'PAUSAS', 'SCORE', 'WORKTREE', 'LEASES'],
+        conducao: 'Conducao agora', variantes: '  Variantes de ciclo em uso:',
+        batch: (total) => `Fila de batch scoring: ${total} thread(s) esperando score humano`,
+        batchVeja: '  veja em: ork master (com o indice derivado do ledger)',
+        desconhecido: (sub) => `subcomando desconhecido: board ${sub}`,
+        uso: 'uso: ork board [list|plan|reap] [--all] [--por <quem>] [--json]',
+        semRemoto: (projeto, remoto) => `Outras maquinas: o projeto ${projeto} nao tem o remoto ${remoto}; nada foi lido de ork/fabrica-estado.`,
+    },
+    monitor: {
+        desconhecido: (sub) => `subcomando desconhecido: orquestracao ${sub}`,
+        uso: 'uso: ork orquestracao status [--all] [--json] [--atencao N] [--so-paradas]',
+        atencao: (valor) => `--atencao espera minutos (inteiro >= 0), recebeu "${valor}"`,
+        titulo: (projeto, threads, perfis, nomes) => `Monitor de orquestracao, projeto ${projeto} (${threads} thread(s) em ${perfis} perfil(is): ${nomes})`,
+        resumo: (humano, impedimento, andamento, avancar, fechadas) => `  aguardando humano: ${humano} | com impedimento: ${impedimento} | em andamento: ${andamento} | ` +
+            `podem avancar: ${avancar} | fechadas: ${fechadas}`,
+        limite: (minutos, acima) => `  limite de atencao: ${minutos} min (${acima} parada(s) acima, marcadas com !)`,
+        runtime: (detalhe) => `  [warn] ${detalhe}: pausa prevista e reportada como valendo`,
+        conduzidas: 'Conduzidas agora:',
+        nenhuma: '  Nenhuma thread parada: ninguem esperando veredito humano nem impedido.',
+        colunas: ['PERFIL', 'THREAD', 'FASE', 'STATUS', 'BLOCO QUE PAUSA', 'AGUARDA DO HUMANO',
+            'IMPEDIMENTO', 'ULTIMO EVENTO', 'PARADA HA'],
+        situacoes: {
+            'em-andamento': 'em-andamento', 'pode-avancar': 'pode-avancar', espera: 'espera',
+            pausada: 'pausada', fechada: 'fechada',
+        },
+        nao: 'nao', semLedger: '(sem ledger)',
+        esperando: 'Esperando VEREDITO HUMANO agora (o orquestrador deve avisar o humano):',
+        impedidas: 'Com IMPEDIMENTO (nao e veredito humano: e colisao, gate, limite ou janela):',
+        previstas: 'Pausa PREVISTA, sessao ainda viva (nao avise ainda, mas ja e a proxima fila):',
+        parada: (motivo, duracao, desde) => `      [${motivo}] parada ha ${duracao} (desde ${desde})`,
+        humanoDecide: (valor) => `      o humano decide: ${valor}`,
+        detalhe: (valor) => `      detalhe  : ${valor}`,
+        evidencia: (valor) => `      evidencia: ${valor}`,
+        correcao: (valor) => `      correcao : ${valor}`,
+        vaiPausar: (thread, bloco, sobre) => `  ${thread}: ${bloco} vai pausar sobre "${sobre}"`,
+    },
+    licoes: {
+        resumo: (threads) => `Das ${threads} threads ja fechadas pelo MASTER neste produto:`,
+        bloqueio: (nome, total, unidade, dica) => `- o bloqueio ${nome} apareceu em ${total} ${unidade}${dica ? `; o que evita: ${dica}` : ''}`,
+        classe: (nome, total, unidade, dica) => `- a classe de falha ${nome} fechou ${total} ${unidade}${dica ? `; o que evita: ${dica}` : ''}`,
+        nota: (thread, score, justificativa) => `- ${thread} fechou com ${score}/5: ${justificativa}`,
+        titulo: 'Licoes que voltam no GOAL e no PLAN da proxima thread',
+        nenhuma: 'Nenhuma thread fechada pelo MASTER ainda: nada a ensinar.',
+        propostas: (piso, dias) => `Propostas de policy (a mesma falha em ${piso}+ threads nos ultimos ${dias} dias):`,
+        propostaNenhuma: '  nenhuma',
+        fecho: 'Proposta nao bloqueia nada: vira policy so quando o dono a declara em `policies:` no orkastery.yaml.',
+    },
+    demo: {
+        gitFalhou: (acao, detalhe) => `demo: git ${acao} falhou: ${detalhe}`,
+        dirNaoVazio: (dir) => `demo: ${dir} nao esta vazio; a demo cria o proprio repositorio`,
+        titulo: 'ork demo: a afirmacao do agente contra a prova',
+        passo1: '  1. O agente entrega soma.js e diz: "soma(2, 2) devolve 4. Pronto."',
+        passo2: '  2. O ork nao aceita relato: reexecuta a prova no commit real.',
+        vereditoAntes: (ok, motivos) => `     Veredito: ${ok ? 'VERDADE SUSTENTADA' : `REPROVADO (${motivos})`}. A funcao faz a - b.`,
+        passo3: '  3. O agente corrige soma.js e faz commit.',
+        passo4: '  4. O ork reexecuta a MESMA prova no commit novo.',
+        vereditoDepois: (ok, motivos) => `     Veredito: ${ok ? 'VERDADE SUSTENTADA' : `REPROVADO (${motivos})`}.`,
+        principio: 'Nenhuma afirmacao vale sem o comando que a julga, reexecutado no commit real.',
+        proximo: 'No seu projeto: ork init, depois ork thread new "<pedido>" --modo auto.',
+        mantido: (dir) => `(o repositorio da demo ficou em ${dir})`,
+    },
+    fabrica: {
+        publicou: (maquina, threads, commit, tentativas) => `Fabrica: ${maquina} publicou ${threads} thread(s) em ork/fabrica-estado (${commit}, ${tentativas} tentativa(s)).`,
+        ocupada: 'Fabrica: outra publicacao desta maquina esta em andamento; tente de novo em instantes.',
+        igual: (maquina) => `Fabrica: retrato de ${maquina} igual ao ultimo publicado; nada a enviar (use --forcar para publicar mesmo assim).`,
+        soQuandoPede: '  esta maquina nao entrou na fabrica compartilhada: so publica quando voce pede (ork fabrica entrar liga).',
+        manifestoPede: '  o orkastery.yaml pede a fabrica compartilhada; quem liga e a maquina, com ork fabrica entrar.',
+        entrou: (maquina) => `Fabrica: esta maquina entrou como ${maquina}; publica ao criar thread, despachar fase, entregar e fechar,`,
+        primeiro: (threads, commit) => `  e a cada batida do pulse. Primeiro retrato: ${threads} thread(s) em ork/fabrica-estado (${commit}).`,
+        maquinaAmbiente: (maquina) => `  AVISO: ORK_MAQUINA=${maquina} neste shell vence o arquivo; alinhe os dois.`,
+        saiu: (maquina, commit) => `Fabrica: ${maquina} saiu; nada mais e publicado daqui.` +
+            (commit ? ` Retrato removido de ork/fabrica-estado (${commit}).` : ' Nao havia retrato desta maquina na branch.'),
+        ambienteLiga: '  AVISO: ORK_FABRICA_COMPARTILHADA=1 neste shell ainda liga a fabrica aqui.',
+        desconhecido: (sub) => `subcomando desconhecido: fabrica ${sub}`,
+        uso: 'uso: ork fabrica [--json] [--sem-remoto] | fabrica publicar [--forcar] [--json] | fabrica entrar [--maquina NOME] | fabrica sair' +
+            ' | fabrica batida [status|instalar|remover] [--por Q] [--json]',
+        semRemoto: (projeto, remoto) => `Fabrica: o projeto ${projeto} nao tem o remoto ${remoto}; nada foi lido de ork/fabrica-estado.`,
+        estaMaquina: ' (esta maquina)',
+        maquina: (nome, propria, por, publicado, ativas, entregues) => `${nome}${propria}, ${por}, publicado ${publicado}: ${ativas} thread(s) ativa(s)` +
+            (entregues ? `, ${entregues} entregue(s) sem MASTER` : ''),
+        colunas: ['THREAD', 'MODO', 'FASE', 'RUNTIME', 'ITEM', 'ESPERA VOCE', 'SESSAO'],
+        espera: (valor) => `sim: ${valor}`,
+        veredito: 'veredito',
+        copia: 'AVISO: sem leitura nova do remoto; esta e a ultima copia lida nesta maquina.',
+        nenhuma: (branch) => `Nenhuma maquina publicou ainda em ${branch}. Publique esta com: ork fabrica publicar`,
+        origens: { atual: 'lido agora', copia: 'ultima copia local' },
+        outrasNenhuma: (branch, origem) => `Outras maquinas (${branch}, ${origem}): nenhuma publicou ainda.`,
+        outras: (branch, origem) => `Outras maquinas (${branch}, ${origem}):`,
+        pedida: 'fabrica.nao-confirmada: o orkastery.yaml pede fabrica.compartilhada: true, mas quem liga a publicacao ' +
+            'do retrato desta maquina e a propria maquina, nao o repositorio. Nada foi publicado. Para entrar: ork fabrica entrar',
+        batida: {
+            titulo: (maquina, projeto) => `Batida da fábrica em ${maquina}, projeto ${projeto}`,
+            naoLido: (motivo) => `  crontab: não lido (${motivo}); não dá para dizer se a batida está instalada`,
+            naoInstalada: '  instalada: não; instale com: ork fabrica batida instalar',
+            horarioIlegivel: 'com horário que o ork não lê', aCada: (min) => `a cada ${min} min`,
+            instalada: (ritmo, gerenciada) => `  instalada: sim, ${ritmo}${gerenciada ? ', pelo ork fabrica batida instalar' : ', por linha posta à mão'}`,
+            linha: (valor) => `  linha: ${valor}`,
+            semRodada: '  última rodada: nenhuma registrada (.orkastery/monitor/hitl.log)',
+            rodada: (hora, min, estado, detalhe) => `  última rodada: ${hora} (há ${min} min), ${estado}: ${detalhe}`,
+            codigo: (code) => code === 0 ? 'ok' : `código ${code ?? '?'}`,
+            semDetalhe: 'sem detalhe',
+            atrasada: (min) => `  atrasada: nenhuma rodada há ${min} min com a batida instalada; confira crontab -l e o hitl.log`,
+            jaInstalada: (projeto, linha) => `Batida já instalada para ${projeto}; nada mudou no crontab.\n  linha: ${linha}`,
+            instalou: (projeto, evento) => `Batida instalada para ${projeto} (evento ${evento} no ledger da máquina).`,
+            removeu: (projeto, evento) => `Batida removida de ${projeto} (evento ${evento} no ledger da máquina).`,
+            nenhumaInstalada: (projeto) => `Nenhuma batida do ork instalada para ${projeto}; nada mudou no crontab.`,
+            saiu: (linha) => `  saiu: ${linha}`,
+            ficou: (linha) => `  ficou (posta à mão, não é do ork): ${linha}`,
+            confira: '  confira com: ork fabrica batida status',
+            uso: 'uso: ork fabrica batida [status|instalar|remover] [--por Q] [--json]',
+        },
+    },
+    eval: {
+        fixtureFormato: (nome) => `${nome}: esperado { skill, casos[] }`,
+        casosMinimos: (casos, minimo) => `${casos} caso(s); o minimo do catalogo e ${minimo}`,
+        tipoFaltando: (tipo) => `nenhum caso do tipo "${tipo}"`, idRepetido: 'id repetido no corpus',
+        idPrefixo: (skill) => `o id precisa comecar com "${skill}/"`,
+        racionalizacao: 'caso de racionalizacao sem o campo `racionalizacao` com a desculpa',
+        assercaoPorque: (valor) => `assercao "${valor}" sem o campo \`porque\``,
+        padraoInvalido: (valor, detalhe) => `padrao "${valor}" invalido: ${detalhe}`,
+        deveriaAusente: (valor, vezes) => `"${valor}" deveria estar AUSENTE da skill e aparece ${vezes}x`,
+        naoExiste: (valor, skill, porque) => `"${valor}" nao existe em skills/.../${skill}/SKILL.md (${porque})`,
+        ancora: 'todas as ancoras deste caso estao dentro da tabela de racionalizacoes: a skill lista a desculpa mas nao carrega a regra que responde a ela',
+        filtroVazio: 'filtro de canários vazio: nenhuma prova foi executada',
+        canarioAusente: (id) => `canário solicitado ausente: ${id}`,
+        casoAusente: (nome) => `${nome}: falta caso.json`,
+        fixtureDiverge: 'id da fixture diverge do canário solicitado',
+        semExecutor: (nome, id) => `${nome}: nenhum executor registrado para o canario "${id}"`,
+        semGit: 'git nao esta nesta maquina: o canario sai unavailable, nunca passing',
+        divergencia: (esperado, observado) => `esperado ${esperado}, observado ${observado}`,
+        canarioSemFixture: (id) => `o canario ${id} existe no codigo e nao tem eval/fixtures/${id}/caso.json`,
+        skillSemEval: (skill) => `skill sem eval nao entra no catalogo: falta eval/casos/${skill}.json`,
+        evalSemSkill: 'ha casos para uma skill que nao existe no catalogo',
+        titulo: (catalogo) => `ork eval, catalogo em ${catalogo}`,
+        canarios: 'Canarios (comportamento real do nucleo, contra git de verdade)',
+        colunasCanarios: ['CANARIO', 'ESTADO', 'SOBRE'],
+        estados: { passou: 'passou', unavailable: 'unavailable', falhou: 'falhou' },
+        skills: 'Corpus das skills (a metade estatica: as regras que precisam existir no arquivo)',
+        colunasSkills: ['SKILL', 'CASOS', 'ASSERCOES', 'FALHAS'], falhas: 'Falhas',
+        resumoCanarios: (passaram, total, indisponiveis) => `canarios: ${passaram}/${total} verdes${indisponiveis > 0 ? ` (${indisponiveis} unavailable)` : ''}`,
+        resumoSkills: (skills, casos, assercoes, falhas) => `skills: ${skills} | casos: ${casos} | assercoes: ${assercoes} | falhas: ${falhas}`,
+        metade: 'metade comportamental (o agente resiste a desculpa?): unavailable, julgada por humano ou por modelo, nunca por este runner',
+        veredito: (ok) => `VEREDITO: ${ok ? 'verde' : 'vermelho'}`,
+    },
+    memory: {
+        cli: {
+            inventario: (tenant, incluidos, excluidos) => `Inventario do tenant ${tenant}: ${incluidos} incluidos, ${excluidos} excluidos.`,
+            fonte: (incluir, arquivo, motivo) => `  ${incluir ? 'incluir' : 'excluir'} ${arquivo}: ${motivo}`,
+            migracao: (tenant, confirmados, falhas, excluidos) => `Migracao do tenant ${tenant}: ${confirmados} confirmados, ${falhas} falhas, ${excluidos} excluidos.`,
+            tagsUso: 'uso: ork memory search --tags \'{"project":["orkastery"],"skill":["orkastery-decision"]}\'',
+            tagsInvalidas: (erro) => `--tags nao e JSON valido: ${erro}`,
+            files: (motivo) => `memory.query.files: ${motivo}; resultado nao comprova ausencia na memoria semantica`,
+            buscaTag: (regime) => `Busca deterministica por tag (regime ${regime})`,
+            correcao: (valor) => `  correcao: ${valor}`,
+            entradas: (n) => `  ${n} entrada(s)`,
+            indexUso: 'uso: ork memory index [--modelo primario|fallback|todos] [--dry-run] [--json]',
+            indexFalha: (regime, motivo, correcao) => `memory.index: regime ${regime} (${motivo}); ${correcao}`,
+            universoFalhou: (motivo, detalhe) => `memory.index: ${motivo}; ${detalhe}`,
+            universoDetalhe: 'o universo da busca nao foi lido inteiro; nada foi embedado',
+            desconhecido: (sub) => `subcomando desconhecido: memory ${sub}`,
+            textoExclusivo: 'memory.search.texto-exclusivo: --texto nao combina com --tags, --thread, --restrito nem --janela',
+            textoUso: (modos, colecoes, limite) => `uso: ork memory search --texto "<frase>" [--modo ${modos}] [--colecao ${colecoes}] [--limite 1..${limite}] [--json]`,
+            buscaUniversoDetalhe: 'o universo da busca nao foi lido inteiro; nada foi buscado',
+            syncDetalhe: 'sync nao executado; colisao legada nao foi reavaliada',
+        },
+        estado: {
+            titulo: 'Regime de memoria do projeto', pedido: (v) => `  pedido no manifesto   ${v}`,
+            efetivo: (v) => `  regime efetivo        ${v}`, tenant: (v) => `  tenant                ${v}`,
+            variavel: (v) => `  variavel da base      ${v || '(nao declarada)'}`,
+            dsn: (sim) => `  DSN no ambiente       ${sim ? 'sim (valor nunca impresso)' : 'nao'}`,
+            // RM-069 (D5): com a fonte de arquivo, o arquivo pelo rotulo com `~` e se a DSN esta nele, nunca o valor.
+            arquivo: (v) => `  arquivo da base       ${v}`,
+            dsnNoArquivo: (sim) => `  DSN no arquivo        ${sim ? 'sim (valor nunca impresso)' : 'nao'}`,
+            cli: (v) => `  cli do OrkMind        ${v}`, degradacao: (v) => `  degradacao: ${v}`,
+            correcao: (v) => `    correcao: ${v}`,
+            continua1: '  O ciclo NAO para por isso: em regime files o handoff continua triado em 3 niveis,',
+            continua2: '  os ponteiros continuam `path#ancora` e `ork recall` continua resolvendo.',
+            colecoes: (v) => `  colecoes gravadas: ${v}`,
+            governanca: '  governanca: source=agent; decision/human exige human_gate comprovado; mandatory=false e regra nunca critical.',
+        },
+        embeddings: {
+            titulo: 'Busca por significado (embeddings, nao deterministica; o recall por tag nao muda)',
+            provider: (v) => `  provider              ${v}`, desligada: 'none (desligada)',
+            chave: (nome, presente) => `  chave                 ${nome} ${presente ? 'presente' : 'ausente'} no ambiente (valor nunca impresso)`,
+            fallback: (v) => `  fallback local        ${v}`, naoDeclarado: '(nao declarado)',
+            cache: (dim) => `no cache (${dim} dim)`, foraCache: 'ausente do cache',
+            deps: (v) => `dependencias ${v}`, depsOk: 'ok', depsAusentes: 'ausentes', depsNaoSondadas: 'nao sondadas',
+            ativo: (v, sondado) => `  caminho ativo         ${v}${sondado ? '' : ' (ponte nao sondada)'}`,
+            universo: (n, colecoes) => `  universo da busca     ${n} entrada(s) do tenant: ${colecoes}`,
+            fora: (v) => `  fora da busca         ${v}`,
+            universoFalhou: (v) => `  universo da busca     nao lido (${v}); cobertura nao calculada`,
+            indice: (modelo, dim, vetores, coerentes, desatualizados) => `  indice                ${modelo} / ${dim} dim: ${vetores} vetor(es), ${coerentes ?? '?'} coerente(s), ${desatualizados ?? '?'} desatualizado(s)`,
+            cobertura: (v, entradas) => `  cobertura             ${v} de ${entradas} entrada(s) do universo da busca`,
+            aviso: (v) => `  aviso                 ${v}`,
+            sondaOk: (alvo, ms) => `${alvo} respondeu em ${ms} ms`,
+            sondaFalha: (motivo) => `sem resposta (${motivo})`, semCaminho: 'sem caminho ativo',
+            sonda: (v) => `  sonda                 ${v}`, motivo: (v) => `  motivo                ${v}`,
+        },
+        sync: {
+            titulo: (regime, thread) => `Sincronizacao de memoria (regime ${regime})${thread ? ` da thread ${thread}` : ''}`,
+            perfil: (perfil, fora) => `Perfil: ${perfil}; fora do perfil: ${fora || '(nenhuma)'}`,
+            pendente: (motivo) => `Publicacao pendente: ${motivo}`,
+            entradas: (nome, total, detalhe) => `  ${nome.padEnd(10)} ${total} entrada(s): ${detalhe}`,
+            humanos: (elegiveis, excluidos, falhas) => `  human_gate ${elegiveis} elegiveis, ${excluidos} excluidos, ${falhas} falhas`,
+            gravacao: (nome, valor) => `  ${nome.padEnd(10)} ${valor}`,
+            jaExiste: 'ja existente', gravado: 'gravado', naoGravado: (v) => `nao gravado: ${v}`,
+            nada: '(nada a gravar)', total: (n, falhas) => `  total ${n} tentativa(s), ${falhas} sem gravacao`,
+            correcao: (v) => `  correcao: ${v}`,
+        },
+        indice: {
+            custoNaoEstimado: 'nao estimado', semModelo: '(sem modelo)',
+            titulo: (alvo, dry, modelo, dim) => `Indice vetorial (${alvo}${dry ? ', --dry-run' : ''}): ${modelo}${dim ? ` / ${dim} dim` : ''}`,
+            universo: (n, colecoes, coerentes) => `  universo da busca    ${n} entrada(s): ${colecoes}; coerentes ${coerentes}`,
+            fora: (v) => `  fora da busca        ${v}`,
+            embedados: (n, reescritos, removidos) => `  embedados            ${n} (reescritos ${reescritos}); removidos ${removidos}`,
+            recusados: (n, limite) => `  fora do indice       ${n} recusada(s) por padrao de segredo, ${limite} acima do limite`,
+            truncados: (n) => `  truncados            ${n} acima do contexto do modelo local, embedados pelo comeco`,
+            estimativa: (tokens, custo, chamadas) => `  estimativa           ${tokens} token(s), ${custo}; chamadas ao provider ${chamadas}`,
+            arquivo: (v) => `  arquivo              ${v}`, motivo: (m, d) => `  motivo               ${m}: ${d}`,
+            foraMedido: (injecao, expiradas, outras) => `${injecao} com injection_risk e ${expiradas} expirada(s) (governanca da biblioteca), ${outras} em outras colecoes (fora da busca do ork); nada disso vai ao embed`,
+            foraNaoMedido: 'nao medido nesta base',
+        },
+        busca: {
+            titulo: (modo, origem, modelo) => `Busca por significado (NAO deterministica; modo ${modo}, origem ${origem}${modelo ? ` ${modelo}` : ''})`,
+            motivo: (v, detalhe) => `  motivo: ${v}${detalhe ? `; ${detalhe}` : ''}`,
+            detalhe: (v) => `  detalhe: ${v}`, similaridade: (v) => `  similaridade ${v}`,
+            resumo: (n) => `  ${n} resultado(s); busca por tag continua em ork memory search --tags`,
+        },
+    },
+    mcp: {
+        uso: 'uso: ork mcp serve|install --project <raiz absoluta> --host codex|claude-code [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... somente install forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate somente install Codex] [--dry-run somente install]',
+        erro: (detalhe) => `mcp: ${detalhe}`,
+        simulacao: 'Simulacao: nenhuma escrita.',
+        preparada: 'Configuracao MCP preparada.',
+        inicio: 'Abra uma nova sessao neste projeto, conclua o consentimento nativo solicitado pelo cliente e confira a descoberta das ferramentas ork_*.',
+        ativacao: 'Ativacao e uso ainda pendentes de verificacao no cliente. Respostas automaticas de elicitation nao devem estar habilitadas para decisoes do dono.',
+    },
+};
+exports.OPERACAO_RESTANTE_EN = {
+    sessions: {
+        atencao: (value) => `--atencao expects minutes (integer >= 0), received "${value}"`,
+        usoWatch: 'usage: ork sessions watch --thread T [--sessao ID] [--once]',
+        sessaoDaThread: 'session does not belong to the thread',
+        usoEvent: 'usage: ork sessions event --tipo <type> --sessao <id> < payload.json (maximum 16384 bytes)',
+        eventoRecusado: (detail) => `event rejected: ${detail}`,
+        exigeProjeto: 'ork sessions limpar-fantasmas requires a project (orkastery.yaml)',
+        request: 'sessions request requires thread, UUID, --fase, and --runtime; --pergunta only checks the native content',
+        answer: 'sessions answer requires thread, request, and an authenticated envelope on --stdin',
+        reconcile: 'sessions reconcile requires thread and request',
+        supersede: 'sessions supersede requires thread, UUID, --fase, and --runtime',
+        usoSub: (sub) => `usage: ork sessions ${sub} <session>`,
+        desconhecido: (sub) => `unknown subcommand: sessions ${sub}`,
+        inventario: {
+            abertura: (global, user, history) => `${global ? 'Global' : 'Project'} inventory for account ${user}; history: ${history ? 'included' : 'omitted'}.`,
+            fontes: (value) => `Sources: ${value}`,
+            fonteEstado: { ausente: 'missing', ok: 'ok', falha: 'FAILED' },
+            resumo: (total, unbound, ambiguous, ghosts, ok) => `Total: ${total}; without thread: ${unbound}; ambiguous: ${ambiguous}; ghosts: ${ghosts}; query: ${ok ? 'valid' : 'INCOMPLETE'}.`,
+            colunas: ['ID', 'RUNTIME', 'PROFILE', 'STATE', 'THREAD/PHASE'],
+            processo: 'process', desconhecido: 'unknown', fantasma: 'ghost', fora: '(outside ork)',
+            explicacaoFantasma: 'Ghost: record without a live process; it occupies no slot. `ork sessions limpar-fantasmas` releases the ork link without touching the runtime.',
+            falha: (detail) => `Failure: ${detail}`,
+            ausente: (detail, fix) => `Missing: ${detail}${fix ? `; fix: ${fix}` : ''}`,
+        },
+        localizar: {
+            ambigua: (key, accounts) => `session "${key}" found in more than one account: ${accounts}; use the full id`,
+            ausente: (key, failures) => `session "${key}" not found in the runtime${failures ? `; accounts without a response: ${failures}` : ''}`,
+            parada: (id, profile) => `session ${id} stopped${profile ? ` (profile ${profile})` : ''}`,
+        },
+        limpeza: {
+            nenhuma: (partial) => `No ghost session${partial ? ' in the accounts that responded' : ''}.`,
+            falha: (detail) => `Failure: ${detail}`,
+            acoes: {
+                soltaria: 'would release (sessao_morta in the ledger)', solto: 'released: sessao_morta in the ledger',
+                jaSolto: 'already closed in the ledger', semThread: 'outside ork: nothing to release',
+                outroProjeto: 'linked to another project: run it there',
+            },
+            abertura: (dryRun) => `Ghost sessions (no pid and no process)${dryRun ? ', dry run: nothing was written' : ''}. The runtime was not touched.`,
+            colunas: ['ID', 'PROFILE', 'THREAD/PHASE', 'ACTION'],
+            processo: 'process',
+        },
+        radar: {
+            titulo: (total) => `Runtime session radar (${total} session(s) on this machine)`,
+            resumo: (human, hitl, abandoned, failures, unknown, working, outside) => `  need a human: ${human} (live HITL ${hitl}, abandoned ${abandoned}, failure ${failures}, ` +
+                `unknown state ${unknown}) | working: ${working} | outside ork: ${outside}`,
+            limite: (minutes, above) => `  attention threshold: ${minutes} min (${above} stopped above it, marked with !)`,
+            falha: (detail) => `  [fail] ${detail}: cannot tell who is stopped`,
+            semLogs: '  [warn] --sem-logs: the radar says WHO is stopped, but not WHAT each session is asking',
+            nenhuma: '  No session in this scan.',
+            colunas: ['ID', 'NAME', 'CLASS', 'STATE', 'TYPE', 'DIRECTORY', 'THREAD', 'AGE'],
+            vazio: '(empty)', fora: 'outside ork', nenhumaEsperando: '  No session is waiting for a human.',
+            vivas: 'Waiting for a HUMAN now, with the job LIVE (answering unblocks it immediately):',
+            mortas: 'DIED waiting for an answer (the job exited; answering no longer helps and the work stopped):',
+            onde: 'where', porque: 'why', pergunta: 'question', log: 'log', opcao: 'option',
+            parada: 'stopped for', viva: 'alive for', ver: 'view', responder: 'answer', recomendo: 'recommend',
+            thread: (id, phase) => `thread ${id}, phase ${phase}`,
+            sessaoFora: 'session outside ork',
+            paradaDesconhecida: 'unknown; record with --registrar',
+            desdeObservacao: 'since the first observation', idade: 'session age', desdeInicio: 'since the session started',
+        },
+    },
+    gate: {
+        usoContext: 'usage: ork gate context <thread> <request> [--native-offer-stdin]',
+        requestThread: 'gate request requires a thread',
+        formato: 'gate request: --formato telegram|terminal',
+        answer: 'gate answer requires thread, request, and --resposta-stdin',
+        usoNext: 'usage: ork gate next <thread-id> [--proximo PHASE] [--ocupacao 0..1]',
+        approveAposentado: 'gate approve is retired: approval without a request is refused. Use ork gate request <thread-id> and answer through authenticated human ingress.',
+        registrado: (thread) => `Human authorization recorded in the ledger of thread ${thread}.`,
+        sobre: (value) => `  subject       ${value}`,
+        autorizado: (value) => `  authorized by ${value}`,
+        quando: (value) => `  when          ${value}`,
+        desconhecido: (sub) => `unknown subcommand: gate ${sub}`,
+        tokens: {
+            titulo: (thread) => `ork gate next: thread ${thread}`,
+            ocupacao: (value) => `  occupancy     ${value}`,
+            naoMedivel: 'not measurable',
+            fonte: (value) => `  source        ${value}`,
+            detalhe: (value) => `                 ${value}`,
+            limiares: (rotate, force) => `  thresholds     rotate_above ${rotate} | force_rotate_above ${force}`,
+            proximo: (phase, weight) => `  next step     ${phase} (${weight})`,
+            pesado: 'heavy', leve: 'light',
+            veredito: (value, source) => `VERDICT: ${value}  (decided by ${source})`,
+            razao: (value) => `  reason: ${value}`,
+            slug: (value) => `  new session slug: ${value}`,
+            handoff: (thread, phase) => `  next step: ork handoff export ${thread} --proxima-fase ${phase}`,
+            ledger: (thread) => `Recorded in the ledger as token_gate: ork phase list ${thread}`,
+            localizarDetalhe: (source, value) => {
+                if (source === 'unavailable' && value.startsWith('transcript informado nao existe: '))
+                    return value.replace('transcript informado nao existe: ', 'provided transcript does not exist: ');
+                if (source === 'estimated')
+                    return value
+                        .replace(/^estimativa por tamanho: /, 'size estimate: ')
+                        .replace(/ bytes por token = ~/, ' bytes per token = ~')
+                        .replace(/ tokens de uma janela nominal de /, ' tokens in a nominal window of ');
+                if (source === 'runtime_reported')
+                    return value.replace(/^uso de contexto lido do runtime para a sessao /, 'context usage read from the runtime for session ');
+                if (source === 'informada')
+                    return value.replace(/^ocupacao ([\d.]+)% declarada pelo chamador como fonte /, '$1% occupancy declared by the caller as source ');
+                return value.replace('o adapter claude-bg nao expoe uso de contexto nesta versao do runtime; nenhuma outra fonte foi informada', 'the claude-bg adapter does not expose context usage in this runtime version; no other source was provided');
+            },
+            localizarRazao: (occupancy, rotate, force, heavy, redo, next, value) => {
+                if (occupancy === null)
+                    return 'window occupancy is not measurable (source unavailable): rotation is NOT decided from ' +
+                        'missing data. Continue in the same session and rotate by explicit decision if needed.';
+                const pct = (occupancy * 100).toFixed(1);
+                if (occupancy >= force)
+                    return `occupancy ${pct}% >= force_rotate_above (${(force * 100).toFixed(0)}%): ` +
+                        'always rotate, regardless of the weight of the next step.';
+                if (occupancy >= rotate && heavy)
+                    return `occupancy ${pct}% >= rotate_above (${(rotate * 100).toFixed(0)}%) and the next step is heavy ` +
+                        `(${redo ? 'redo failed phase' : next}): more window means more accuracy.`;
+                if (occupancy >= rotate)
+                    return `occupancy ${pct}% >= rotate_above, but the next step (${next}) is not heavy: continue in the same session.`;
+                if (Number.isFinite(occupancy))
+                    return `occupancy ${pct}% below rotate_above (${(rotate * 100).toFixed(0)}%): continue in the same session.`;
+                return value;
+            },
+        },
+    },
+    fix: {
+        usoOpen: 'usage: ork fix open <thread-id> [--so-claims] [--reverify]',
+        usoList: 'usage: ork fix list <thread-id> [--rodada N]',
+        semRodada: (thread) => `Thread ${thread} has no GO-FIX round. Open one with: ork fix open ${thread}`,
+        lista: (round, thread) => `Fixes from round ${round} of thread ${thread}`,
+        colunasLista: ['ID', 'TYPE', 'REASON', 'TARGET', 'STATE', 'JUDGED BY'],
+        usoReverify: 'usage: ork fix reverify <thread-id> [--rodada N] [--parcial]',
+        desconhecido: (sub) => `unknown subcommand: fix ${sub}`,
+        semCorrecoes: (thread) => `Thread ${thread}: CHECK PASSED on the real HEAD; there is no fix to open.\n` +
+            '  (no blocking typed reason in `ork verify`)',
+        aberto: (thread, round) => `GO-FIX opened for thread ${thread} (round ${round})`,
+        veredito: (value) => `  CHECK verdict       ${value}`,
+        motivos: (value) => `  typed reasons       ${value}`,
+        reexecucao: (typeB) => `  rerun               ${typeB ? 'FULL required (there is a type B fix)' : 'partial allowed (type A-only round)'}`,
+        colunas: ['ID', 'TYPE', 'REASON', 'TARGET', 'JUDGED BY'],
+        verifyCompleto: '(full verify)',
+        spec: 'Exact spec dispatched to GO-FIX:',
+        reverify: (thread, round) => `CHECK-REVERIFY for thread ${thread} (round ${round})`,
+        cobertura: (value) => `  coverage    ${value}`,
+        rodadas: (rounds, limit) => `  rounds      ${rounds} of ${limit} before escalation`,
+        porCorrecao: 'Verdict by fix:',
+        correcao: (id, type, approved, target) => `  ${id}  type ${type}  ${approved ? 'APPROVED' : 'FAILED'}  ${target}`,
+        origem: (value) => `      source reason: ${value}`,
+        execucao: (ok, command) => `      ${ok ? 'ok  ' : 'FAILED'} ${command}`,
+        verify: (commit, ok, reasons) => `Full verify on HEAD ${commit}: ${ok ? 'green' : `failed (${reasons})`}`,
+        final: (value) => `Final verdict: ${value}`,
+        escalado: '  ESCALATED TO A HUMAN: this pause applies in every mode, including #Auto.',
+        vereditos: { PASSOU: 'PASSED', 'PRECISA DE MUDANCA': 'NEEDS CHANGES', BLOQUEADO: 'BLOCKED' },
+        coberturas: { completa: 'full', parcial: 'partial' },
+    },
+    handoff: {
+        usoExport: 'usage: ork handoff export <thread-id> [--proxima-fase PHASE]',
+        historico: (path) => `History: ${path}`,
+        usoRecall: 'usage: ork handoff recall <thread-id> <path#anchor>',
+        resolvido: (location) => `Pointer resolved: ${location}`,
+        metodo: (value) => `  method       ${value}`,
+        sha: (value) => `  sha256       ${value}`,
+        linhas: (value) => `  lines        ${value}`,
+        naoAplicavel: '(not applicable)',
+        desconhecido: (sub) => `unknown subcommand: handoff ${sub}`,
+        exportado: (thread, memory) => `Handoff exported from thread ${thread} (memory regime: ${memory})`,
+        de: (slug, phase) => `  from  ${slug} (phase ${phase})`,
+        para: (slug, phase) => `  to    ${slug} (phase ${phase})`,
+        arquivo: (file) => `  file  ${file}`,
+        critico: (total) => `CRITICAL (${total} item(s), included inline in the new session prompt):`,
+        proveniencia: (location, sha) => `        provenance: ${location} (sha256 ${sha})`,
+        importante: (total) => `IMPORTANT (${total} pointer(s), retrieved on demand):`,
+        quando: (value) => `        when:      ${value}`,
+        recuperar: (value) => `        retrieve:  ${value}`,
+        noMomento: (thread, when) => `        at that time: ork recall ${thread} --fase ${when}`,
+        resumivel: (total) => `SUMMARIZABLE (${total} summary item(s), with declared provenance):`,
+    },
+    recall: {
+        uso: 'usage: ork recall <thread-id> [--fase PHASE] [--id ptr-N] [--todos] [--forcar]',
+        titulo: (thread, moment, regime, handoff) => `Recall for thread ${thread} at ${moment} (effective regime ${regime}, handoff written under regime ${handoff})`,
+        todos: '(all)',
+        resolvidos: (total) => `RESOLVED (${total}, entering context now):`,
+        via: (via, method) => `        via       ${via} (${method})`,
+        location: (value) => `        location  ${value}`,
+        quando: (value) => `        when      ${value}`,
+        adiados: (total) => `DEFERRED (${total}, they exist and do NOT enter now):`,
+        onde: (value) => `        where     ${value}`,
+        recuperar: (thread, phase) => `        retrieve  ork recall ${thread} --fase ${phase}`,
+        falhas: (total) => `FAILURES (${total}):`,
+        motivo: (value) => `        reason    ${value}`,
+        detalhe: (value) => `        detail    ${value}`,
+    },
+    lease: {
+        titulo: 'Project leases',
+        nenhum: '  No lease held. Merging into the base is available.',
+        situacao: { vencido: 'EXPIRED (can be taken)', ativo: 'active' },
+        item: (name, type, thread, state) => `  ${name.padEnd(28)} [${type}] thread ${thread.padEnd(18)} ${state}`,
+        periodo: (from, to, pid) => `    from ${from} to ${to} (pid ${pid})`,
+        motivo: (value) => `    reason: ${value}`,
+        legado: (location) => `    legacy: ${location} (valid while live, within the 30-minute migration window)`,
+        legadoInvalido: (file) => `  legacy: ${file} INVALID or UNREADABLE (ignored)`,
+        legadoPreservado: '    legacy file preserved; ignored without changing the canonical lease',
+        filaRetomada: (total) => `Resume queue: ${total === 0 ? 'empty' : `${total} lease(s)`}`,
+        candidato: (name, pid, ticket, age) => `    ${name} pid ${pid} ${ticket === null ? 'temporary' : `ticket ${ticket}`} age ${age}s`,
+        prazo: '      lease.resume-unavailable: 30-minute window exceeded; acquire again to collect it and check ork lease list',
+        filaInsegura: '    lease.resume-unavailable: unreadable or unsafe queue; inspect candidates before acquiring again',
+        filaMerge: (total) => `Merge queue (lease main-tree): ${total === 0 ? 'empty' : `${total} waiting`}`,
+        esperaMerge: (n, thread, since, by) => `  ${n}. thread ${thread} since ${since} (blocked by ${by})`,
+        filaRegiao: (total) => `Region collision queue: ${total === 0 ? 'empty' : `${total} waiting`}`,
+        esperaRegiao: (n, thread, name, collision, by, since) => `  ${n}. thread ${thread} wants ${name}, collides with ${collision} (thread ${by}) since ${since}`,
+        semMotivo: 'no reason declared',
+        usoAcquire: 'usage: ork lease acquire <name> --thread <thread-id> [--motivo "<reason>"]',
+        adquirido: (name, type, thread) => `Lease ${name} [${type}] acquired by thread ${thread}.`,
+        expira: (value) => `  expires at ${value}`,
+        tomado: '  (the previous lease had EXPIRED and was taken)',
+        naoAdquirido: (name) => `Lease ${name} was NOT acquired.`,
+        motivoTipado: (value) => `  typed reason: ${value}`,
+        detalhe: (value) => `  detail: ${value}`,
+        posicao: (value) => `  queue position: ${value}`,
+        correcao: (value) => `  fix: ${value}`,
+        usoRelease: 'usage: ork lease release <name> [--thread <thread-id>] [--forcar]',
+        desconhecido: (sub) => `unknown subcommand: lease ${sub}`,
+    },
+    board: {
+        reapVazio: 'No slot to return: every open thread is actively seeking work or ready to run.',
+        reapTitulo: (total, zone) => `Slots returned for lack of active demand: ${total}. ${zone}`,
+        reapMarca: { gravada: 'slot_released recorded in the ledger', anterior: 'already recorded (idempotent)' },
+        detalhe: (value) => `    detail    : ${value}`,
+        evidencia: (value) => `    evidence  : ${value}`,
+        filaItem: (n, thread, name, collision, by, since) => `  ${n}. ${thread} wants ${name} (collides with ${collision}, thread ${by}) since ${since}`,
+        planoTitulo: (zone) => `Per-machine scheduler. ${zone}`,
+        limite: (max, running) => `  parallelism limit: ${max} (concurrency.max_parallel_threads) | ` +
+            `running now (active demand): ${running}`,
+        nenhumaThread: '  No thread in the project.',
+        colunasPlano: ['THREAD', 'SLUG', 'MODE', 'PHASE', 'SITUATION', 'REASON', 'DETAIL'],
+        correcoes: '  Actionable fixes:',
+        merge: 'Merge queue (lease main-tree, the only merge gate)',
+        mergeVazia: '  empty: no thread waiting to merge',
+        regiao: 'Region collision queue',
+        regiaoVazia: '  empty: no path, board, or port collision',
+        titulo: (project, threads, profiles, names) => `Orkastery board, project ${project} (${threads} thread(s) in ${profiles} profile(s): ${names})`,
+        vazio: '  No thread yet. Create one with: ork thread new "<name>" --modo default',
+        colunas: ['PROFILE', 'ID', 'SLUG', 'MODE', 'PHASE', 'STATUS', 'PAUSES', 'SCORE', 'WORKTREE', 'LEASES'],
+        conducao: 'Conduction now', variantes: '  Cycle variants in use:',
+        batch: (total) => `Batch scoring queue: ${total} thread(s) waiting for a human score`,
+        batchVeja: '  see: ork master (with the ledger-derived index)',
+        desconhecido: (sub) => `unknown subcommand: board ${sub}`,
+        uso: 'usage: ork board [list|plan|reap] [--all] [--por <who>] [--json]',
+        semRemoto: (project, remote) => `Other machines: project ${project} has no ${remote} remote; nothing was read from ork/fabrica-estado.`,
+    },
+    monitor: {
+        desconhecido: (sub) => `unknown subcommand: orquestracao ${sub}`,
+        uso: 'usage: ork orquestracao status [--all] [--json] [--atencao N] [--so-paradas]',
+        atencao: (value) => `--atencao expects minutes (integer >= 0), received "${value}"`,
+        titulo: (project, threads, profiles, names) => `Orchestration monitor, project ${project} (${threads} thread(s) in ${profiles} profile(s): ${names})`,
+        resumo: (human, impediment, running, advance, closed) => `  waiting for a human: ${human} | with an impediment: ${impediment} | running: ${running} | ` +
+            `can advance: ${advance} | closed: ${closed}`,
+        limite: (minutes, above) => `  attention threshold: ${minutes} min (${above} stopped above it, marked with !)`,
+        runtime: (detail) => `  [warn] ${detail}: planned pause reported as active`,
+        conduzidas: 'Being conducted now:',
+        nenhuma: '  No stopped thread: nobody waiting for a human verdict or blocked.',
+        colunas: ['PROFILE', 'THREAD', 'PHASE', 'STATUS', 'PAUSING BLOCK', 'WAITING FOR HUMAN',
+            'IMPEDIMENT', 'LAST EVENT', 'STOPPED FOR'],
+        situacoes: {
+            'em-andamento': 'running', 'pode-avancar': 'can-advance', espera: 'waiting',
+            pausada: 'paused', fechada: 'closed',
+        },
+        nao: 'no', semLedger: '(no ledger)',
+        esperando: 'Waiting for a HUMAN VERDICT now (the orchestrator must notify the human):',
+        impedidas: 'With an IMPEDIMENT (not a human verdict: collision, gate, limit, or window):',
+        previstas: 'PLANNED pause, session still alive (do not notify yet; it is already the next queue):',
+        parada: (reason, duration, since) => `      [${reason}] stopped for ${duration} (since ${since})`,
+        humanoDecide: (value) => `      the human decides: ${value}`,
+        detalhe: (value) => `      detail   : ${value}`,
+        evidencia: (value) => `      evidence : ${value}`,
+        correcao: (value) => `      fix      : ${value}`,
+        vaiPausar: (thread, block, subject) => `  ${thread}: ${block} will pause for "${subject}"`,
+    },
+    licoes: {
+        resumo: (threads) => `From the ${threads} threads already closed by MASTER in this product:`,
+        bloqueio: (name, total, unit, hint) => `- the ${name} block occurred in ${total} ${unit}${hint ? `; how to prevent it: ${hint}` : ''}`,
+        classe: (name, total, unit, hint) => `- the ${name} failure class closed ${total} ${unit}${hint ? `; how to prevent it: ${hint}` : ''}`,
+        nota: (thread, score, reason) => `- ${thread} closed with ${score}/5: ${reason}`,
+        titulo: 'Lessons brought into the next thread\'s GOAL and PLAN',
+        nenhuma: 'No thread closed by MASTER yet: nothing to teach.',
+        propostas: (floor, days) => `Policy proposals (the same failure in ${floor}+ threads over the last ${days} days):`,
+        propostaNenhuma: '  none',
+        fecho: 'A proposal blocks nothing: it becomes policy only when the owner declares it under `policies:` in orkastery.yaml.',
+    },
+    demo: {
+        gitFalhou: (action, detail) => `demo: git ${action} failed: ${detail}`,
+        dirNaoVazio: (dir) => `demo: ${dir} is not empty; the demo creates its own repository`,
+        titulo: 'ork demo: the agent\'s claim against the evidence',
+        passo1: '  1. The agent delivers soma.js and says: "soma(2, 2) returns 4. Done."',
+        passo2: '  2. ork does not accept self-reporting: it reruns the evidence on the real commit.',
+        vereditoAntes: (ok, reasons) => `     Verdict: ${ok ? 'CLAIM SUPPORTED' : `FAILED (${reasons})`}. The function computes a - b.`,
+        passo3: '  3. The agent fixes soma.js and commits it.',
+        passo4: '  4. ork reruns the SAME evidence on the new commit.',
+        vereditoDepois: (ok, reasons) => `     Verdict: ${ok ? 'CLAIM SUPPORTED' : `FAILED (${reasons})`}.`,
+        principio: 'No claim counts without the command that judges it, rerun on the real commit.',
+        proximo: 'In your project: ork init, then ork thread new "<request>" --modo auto.',
+        mantido: (dir) => `(the demo repository was kept at ${dir})`,
+    },
+    fabrica: {
+        publicou: (machine, threads, commit, attempts) => `Factory: ${machine} published ${threads} thread(s) to ork/fabrica-estado (${commit}, ${attempts} attempt(s)).`,
+        ocupada: 'Factory: another publication from this machine is in progress; try again shortly.',
+        igual: (machine) => `Factory: snapshot from ${machine} matches the last publication; nothing to send (use --forcar to publish anyway).`,
+        soQuandoPede: '  this machine has not joined the shared factory: it publishes only when requested (ork fabrica entrar enables it).',
+        manifestoPede: '  orkastery.yaml requests the shared factory; the machine enables it with ork fabrica entrar.',
+        entrou: (machine) => `Factory: this machine joined as ${machine}; it publishes when creating a thread, dispatching a phase, delivering, and closing,`,
+        primeiro: (threads, commit) => `  and on every pulse heartbeat. First snapshot: ${threads} thread(s) in ork/fabrica-estado (${commit}).`,
+        maquinaAmbiente: (machine) => `  WARNING: ORK_MAQUINA=${machine} in this shell overrides the file; align both values.`,
+        saiu: (machine, commit) => `Factory: ${machine} left; nothing else is published from here.` +
+            (commit ? ` Snapshot removed from ork/fabrica-estado (${commit}).` : ' There was no snapshot for this machine on the branch.'),
+        ambienteLiga: '  WARNING: ORK_FABRICA_COMPARTILHADA=1 in this shell still enables the factory here.',
+        desconhecido: (sub) => `unknown subcommand: fabrica ${sub}`,
+        uso: 'usage: ork fabrica [--json] [--sem-remoto] | fabrica publicar [--forcar] [--json] | fabrica entrar [--maquina NAME] | fabrica sair' +
+            ' | fabrica batida [status|instalar|remover] [--por Q] [--json]',
+        semRemoto: (project, remote) => `Factory: project ${project} has no ${remote} remote; nothing was read from ork/fabrica-estado.`,
+        estaMaquina: ' (this machine)',
+        maquina: (name, own, by, published, active, delivered) => `${name}${own}, ${by}, published ${published}: ${active} active thread(s)` +
+            (delivered ? `, ${delivered} delivered without MASTER` : ''),
+        colunas: ['THREAD', 'MODE', 'PHASE', 'RUNTIME', 'ITEM', 'WAITS FOR YOU', 'SESSION'],
+        espera: (value) => `yes: ${value}`,
+        veredito: 'verdict',
+        copia: 'WARNING: no fresh read from the remote; this is the last copy read on this machine.',
+        nenhuma: (branch) => `No machine has published to ${branch} yet. Publish this one with: ork fabrica publicar`,
+        origens: { atual: 'read now', copia: 'last local copy' },
+        outrasNenhuma: (branch, source) => `Other machines (${branch}, ${source}): none has published yet.`,
+        outras: (branch, source) => `Other machines (${branch}, ${source}):`,
+        pedida: 'fabrica.nao-confirmada: orkastery.yaml requests fabrica.compartilhada: true, but publication of this ' +
+            'machine snapshot is enabled by the machine itself, not the repository. Nothing was published. To join: ork fabrica entrar',
+        batida: {
+            titulo: (machine, project) => `Factory heartbeat on ${machine}, project ${project}`,
+            naoLido: (reason) => `  crontab: not read (${reason}); cannot tell whether the heartbeat is installed`,
+            naoInstalada: '  installed: no; install with: ork fabrica batida instalar',
+            horarioIlegivel: 'on a schedule ork cannot read', aCada: (min) => `every ${min} min`,
+            instalada: (pace, managed) => `  installed: yes, ${pace}${managed ? ', by ork fabrica batida instalar' : ', by a manually added line'}`,
+            linha: (value) => `  line: ${value}`,
+            semRodada: '  last run: none recorded (.orkastery/monitor/hitl.log)',
+            rodada: (time, min, state, detail) => `  last run: ${time} (${min} min ago), ${state}: ${detail}`,
+            codigo: (code) => code === 0 ? 'ok' : `code ${code ?? '?'}`,
+            semDetalhe: 'no detail',
+            atrasada: (min) => `  late: no run for ${min} min with the heartbeat installed; check crontab -l and hitl.log`,
+            jaInstalada: (project, line) => `Heartbeat already installed for ${project}; crontab did not change.\n  line: ${line}`,
+            instalou: (project, event) => `Heartbeat installed for ${project} (event ${event} in the machine ledger).`,
+            removeu: (project, event) => `Heartbeat removed from ${project} (event ${event} in the machine ledger).`,
+            nenhumaInstalada: (project) => `No ork heartbeat installed for ${project}; crontab did not change.`,
+            saiu: (line) => `  removed: ${line}`,
+            ficou: (line) => `  kept (manually added, not owned by ork): ${line}`,
+            confira: '  check with: ork fabrica batida status',
+            uso: 'usage: ork fabrica batida [status|instalar|remover] [--por Q] [--json]',
+        },
+    },
+    eval: {
+        fixtureFormato: (name) => `${name}: expected { skill, casos[] }`,
+        casosMinimos: (cases, minimum) => `${cases} case(s); the catalog minimum is ${minimum}`,
+        tipoFaltando: (type) => `no case of type "${type}"`, idRepetido: 'duplicate id in the corpus',
+        idPrefixo: (skill) => `the id must start with "${skill}/"`,
+        racionalizacao: 'rationalization case without the `racionalizacao` field containing the excuse',
+        assercaoPorque: (value) => `assertion "${value}" without the \`porque\` field`,
+        padraoInvalido: (value, detail) => `invalid pattern "${value}": ${detail}`,
+        deveriaAusente: (value, times) => `"${value}" should be ABSENT from the skill and appears ${times} time(s)`,
+        naoExiste: (value, skill, why) => `"${value}" does not exist in skills/.../${skill}/SKILL.md (${why})`,
+        ancora: 'every anchor in this case is inside the rationalizations table: the skill lists the excuse but does not carry the rule that answers it',
+        filtroVazio: 'empty canary filter: no evidence was executed',
+        canarioAusente: (id) => `requested canary is missing: ${id}`,
+        casoAusente: (name) => `${name}: caso.json is missing`,
+        fixtureDiverge: 'fixture id differs from the requested canary',
+        semExecutor: (name, id) => `${name}: no executor registered for canary "${id}"`,
+        semGit: 'git is not on this machine: the canary is unavailable, never passing',
+        divergencia: (expected, observed) => `expected ${expected}, observed ${observed}`,
+        canarioSemFixture: (id) => `canary ${id} exists in code but has no eval/fixtures/${id}/caso.json`,
+        skillSemEval: (skill) => `a skill without eval does not enter the catalog: eval/casos/${skill}.json is missing`,
+        evalSemSkill: 'there are cases for a skill that does not exist in the catalog',
+        titulo: (catalog) => `ork eval, catalog at ${catalog}`,
+        canarios: 'Canaries (real core behavior, against real git)',
+        colunasCanarios: ['CANARY', 'STATE', 'SUBJECT'],
+        estados: { passou: 'passed', unavailable: 'unavailable', falhou: 'failed' },
+        skills: 'Skills corpus (the static half: rules that must exist in the file)',
+        colunasSkills: ['SKILL', 'CASES', 'ASSERTIONS', 'FAILURES'], falhas: 'Failures',
+        resumoCanarios: (passed, total, unavailable) => `canaries: ${passed}/${total} green${unavailable > 0 ? ` (${unavailable} unavailable)` : ''}`,
+        resumoSkills: (skills, cases, assertions, failures) => `skills: ${skills} | cases: ${cases} | assertions: ${assertions} | failures: ${failures}`,
+        metade: 'behavioral half (does the agent resist the excuse?): unavailable, judged by a human or a model, never by this runner',
+        veredito: (ok) => `VERDICT: ${ok ? 'green' : 'red'}`,
+    },
+    memory: {
+        cli: {
+            inventario: (tenant, included, excluded) => `Tenant ${tenant} inventory: ${included} included, ${excluded} excluded.`,
+            fonte: (include, file, reason) => `  ${include ? 'include' : 'exclude'} ${file}: ${reason}`,
+            migracao: (tenant, confirmed, failures, excluded) => `Tenant ${tenant} migration: ${confirmed} confirmed, ${failures} failures, ${excluded} excluded.`,
+            tagsUso: 'usage: ork memory search --tags \'{"project":["orkastery"],"skill":["orkastery-decision"]}\'',
+            tagsInvalidas: (error) => `--tags is not valid JSON: ${error}`,
+            files: (reason) => `memory.query.files: ${reason}; the result does not prove absence from semantic memory`,
+            buscaTag: (regime) => `Deterministic search by tag (${regime} regime)`,
+            correcao: (value) => `  fix: ${value}`,
+            entradas: (n) => `  ${n} entry(ies)`,
+            indexUso: 'usage: ork memory index [--modelo primario|fallback|todos] [--dry-run] [--json]',
+            indexFalha: (regime, reason, fix) => `memory.index: ${regime} regime (${reason}); ${fix}`,
+            universoFalhou: (reason, detail) => `memory.index: ${reason}; ${detail}`,
+            universoDetalhe: 'the search universe was not read in full; nothing was embedded',
+            desconhecido: (sub) => `unknown subcommand: memory ${sub}`,
+            textoExclusivo: 'memory.search.texto-exclusivo: --texto cannot be combined with --tags, --thread, --restrito, or --janela',
+            textoUso: (modes, collections, limit) => `usage: ork memory search --texto "<phrase>" [--modo ${modes}] [--colecao ${collections}] [--limite 1..${limit}] [--json]`,
+            buscaUniversoDetalhe: 'the search universe was not read in full; nothing was searched',
+            syncDetalhe: 'sync was not executed; the legacy collision was not reevaluated',
+        },
+        estado: {
+            titulo: 'Project memory regime', pedido: (v) => `  requested in manifest ${v}`,
+            efetivo: (v) => `  effective regime      ${v}`, tenant: (v) => `  tenant                ${v}`,
+            variavel: (v) => `  database variable     ${v || '(not declared)'}`,
+            dsn: (yes) => `  DSN in environment    ${yes ? 'yes (value never printed)' : 'no'}`,
+            arquivo: (v) => `  database file         ${v}`,
+            dsnNoArquivo: (yes) => `  DSN in file           ${yes ? 'yes (value never printed)' : 'no'}`,
+            cli: (v) => `  OrkMind CLI           ${v}`, degradacao: (v) => `  degradation: ${v}`,
+            correcao: (v) => `    fix: ${v}`,
+            continua1: '  The cycle does NOT stop because of this: in files regime the handoff remains sorted into 3 tiers,',
+            continua2: '  pointers remain `path#anchor`, and `ork recall` keeps resolving them.',
+            colecoes: (v) => `  stored collections: ${v}`,
+            governanca: '  governance: source=agent; decision/human requires a proven human_gate; mandatory=false and rule is never critical.',
+        },
+        embeddings: {
+            titulo: 'Search by meaning (embeddings, non-deterministic; tag recall does not change)',
+            provider: (v) => `  provider              ${v}`, desligada: 'none (disabled)',
+            chave: (name, present) => `  key                   ${name} ${present ? 'present' : 'missing'} in environment (value never printed)`,
+            fallback: (v) => `  local fallback        ${v}`, naoDeclarado: '(not declared)',
+            cache: (dim) => `in cache (${dim} dim)`, foraCache: 'missing from cache',
+            deps: (v) => `dependencies ${v}`, depsOk: 'ok', depsAusentes: 'missing', depsNaoSondadas: 'not probed',
+            ativo: (v, probed) => `  active path           ${v}${probed ? '' : ' (bridge not probed)'}`,
+            universo: (n, collections) => `  search universe       ${n} tenant entry(ies): ${collections}`,
+            fora: (v) => `  outside search        ${v}`,
+            universoFalhou: (v) => `  search universe       not read (${v}); coverage not calculated`,
+            indice: (model, dim, vectors, coherent, stale) => `  index                 ${model} / ${dim} dim: ${vectors} vector(s), ${coherent ?? '?'} coherent, ${stale ?? '?'} stale`,
+            cobertura: (v, entries) => `  coverage              ${v} of ${entries} search-universe entry(ies)`,
+            aviso: (v) => `  warning               ${v}`,
+            sondaOk: (target, ms) => `${target} answered in ${ms} ms`,
+            sondaFalha: (reason) => `no response (${reason})`, semCaminho: 'no active path',
+            sonda: (v) => `  probe                 ${v}`, motivo: (v) => `  reason                ${v}`,
+        },
+        sync: {
+            titulo: (regime, thread) => `Memory synchronization (${regime} regime)${thread ? ` for thread ${thread}` : ''}`,
+            perfil: (profile, outside) => `Profile: ${profile}; outside profile: ${outside || '(none)'}`,
+            pendente: (reason) => `Publication pending: ${reason}`,
+            entradas: (name, total, detail) => `  ${name.padEnd(10)} ${total} entry(ies): ${detail}`,
+            humanos: (eligible, excluded, failures) => `  human_gate ${eligible} eligible, ${excluded} excluded, ${failures} failures`,
+            gravacao: (name, value) => `  ${name.padEnd(10)} ${value}`,
+            jaExiste: 'already exists', gravado: 'stored', naoGravado: (v) => `not stored: ${v}`,
+            nada: '(nothing to store)', total: (n, failures) => `  total ${n} attempt(s), ${failures} not stored`,
+            correcao: (v) => `  fix: ${v}`,
+        },
+        indice: {
+            custoNaoEstimado: 'not estimated', semModelo: '(no model)',
+            titulo: (target, dry, model, dim) => `Vector index (${target}${dry ? ', --dry-run' : ''}): ${model}${dim ? ` / ${dim} dim` : ''}`,
+            universo: (n, collections, coherent) => `  search universe      ${n} entry(ies): ${collections}; coherent ${coherent}`,
+            fora: (v) => `  outside search       ${v}`,
+            embedados: (n, rewritten, removed) => `  embedded             ${n} (rewritten ${rewritten}); removed ${removed}`,
+            recusados: (n, limit) => `  outside index         ${n} rejected for secret patterns, ${limit} above the limit`,
+            truncados: (n) => `  truncated             ${n} above the local model context, embedded from the beginning`,
+            estimativa: (tokens, cost, calls) => `  estimate              ${tokens} token(s), ${cost}; provider calls ${calls}`,
+            arquivo: (v) => `  file                  ${v}`, motivo: (m, d) => `  reason                ${m}: ${d}`,
+            foraMedido: (injection, expired, others) => `${injection} with injection_risk and ${expired} expired (library governance), ${others} in other collections (outside ork search); none goes to embedding`,
+            foraNaoMedido: 'not measured in this database',
+        },
+        busca: {
+            titulo: (mode, source, model) => `Search by meaning (NON-deterministic; mode ${mode}, source ${source}${model ? ` ${model}` : ''})`,
+            motivo: (v, detail) => `  reason: ${v}${detail ? `; ${detail}` : ''}`,
+            detalhe: (v) => `  detail: ${v}`, similaridade: (v) => `  similarity ${v}`,
+            resumo: (n) => `  ${n} result(s); tag search remains available with ork memory search --tags`,
+        },
+    },
+    mcp: {
+        uso: 'usage: ork mcp serve|install --project <absolute root> --host codex|claude-code [--ship-transport github-ssh|forja-ssh|forja-https|bare-local] [--ssh-fingerprint SHA256:... only for install with forja-ssh] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate only for Codex install] [--dry-run only for install]',
+        erro: (detail) => `mcp: ${detail}`,
+        simulacao: 'Simulation: no writes.',
+        preparada: 'MCP configuration prepared.',
+        inicio: 'Open a new session in this project, complete the native consent requested by the client, and check discovery of the ork_* tools.',
+        ativacao: 'Activation and use still await verification in the client. Automatic elicitation responses must not be enabled for owner decisions.',
+    },
+};