@orkastery/cli 0.5.0 → 0.5.3

package/dist/index.js

@@ -42,6 +42,7 @@ exports.main = main;
 const company_brain_cli_1 = require("./company-brain-cli");
 const estado_thread_1 = require("./estado-thread");
 const intelligence_graph_cli_1 = require("./intelligence-graph-cli");
+const mcp_grafo_1 = require("./mcp-grafo");
 const maestro_cli_1 = require("./maestro-cli");
 const hitl_public_receipt_1 = require("./hitl-public-receipt");
 const hitl_presentation_1 = require("./hitl-presentation");
@@ -106,6 +107,7 @@ const agents_md_1 = require("./agents-md");
 const leases_1 = require("./leases");
 const sessoes_inventario_1 = require("./sessoes-inventario");
 const ledger_stats_1 = require("./ledger-stats");
+const esgotamentos_1 = require("./esgotamentos");
 const sessoes_adopt_1 = require("./sessoes-adopt");
 const sessoes_1 = require("./sessoes");
 const runtime_ambiente_1 = require("./runtime-ambiente");
@@ -145,9 +147,15 @@ const thread_1 = require("./thread");
 const docs_1 = require("./docs");
 const roadmap_reservas_1 = require("./roadmap-reservas");
 const fabrica_estado_1 = require("./fabrica-estado");
+const branch_de_estado_1 = require("./branch-de-estado");
 const network_roadmap_1 = require("./network-roadmap");
 const fabrica_publicar_1 = require("./fabrica-publicar");
 const maquina_1 = require("./maquina");
+const rede_1 = require("./rede");
+const rede_adesao_1 = require("./rede-adesao");
+const saida_segura_1 = require("./saida-segura");
+const rede_forja_1 = require("./rede-forja");
+const rede_status_1 = require("./rede-status");
 const ledger_1 = require("./ledger");
 const tokens_1 = require("./tokens");
 const types_1 = require("./types");
@@ -227,11 +235,11 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   modos                                     Tabela dos ${modos_1.ORDEM_DOS_MODOS.length} modos de conducao vivos por #TAG
 
   setup                                     Pauta da entrevista #setup: runtime/modelo/esforco
+                                            por bloco de cada modo (default claude-bg/opus/high; #Fast: sonnet)
   onboarding [show|set <etapa>|reset [etapa]] Pauta e respostas do projeto (9 etapas)
-        [--conteudo JSON] [--por Q] [--json]  Valores secretos somente em ~/.hermes/.env
+        [--conteudo JSON] [--por Q] [--json]  Segredos ficam ${onboarding_1.ONDE_FICAM_OS_SEGREDOS}
         [--reset [etapa]]                    Reset seletivo ou total, idempotente
   onboarding sync [--json]                  Publicação opcional na memória, com degradação
-                                            por bloco de cada modo (default claude-bg/opus/high; #Fast: sonnet)
   experiencia show [--json]                 Preferências efetivas; configure por onboarding set maestro --conteudo '{"owner":{"experience":true}}'
   experiencia uninstall <host> [--dry-run] [--json]
                                             Remove o bloco de Claude Code/Codex; sem --dry-run aplica a remoção
@@ -244,6 +252,9 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
         [--sem-login]                            do perfil (nunca copia credencial)
   accounts remove <id>                      Desativa o perfil (diretorio e login ficam onde estao)
   accounts check [<id>]                     Confere o login de cada perfil e marca o store
+  accounts esgotamentos [--desde 7d] [--json]
+                                            Despachos numa conta que outro projeto desta maquina viu esgotada
+                                            (RM-040), so leitura: conta opaca, perfil pelo id, sem diretorio
   setup [<modo>] --reset                    Volta o modo (ou tudo) ao default
   setup versionar                           Leva o setup que vale para orkastery.setup.json: por PR, vale em
                                             todas as maquinas e passa a ser o arquivo editado (I-52)
@@ -252,6 +263,9 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
         [--exige-runtime-diferente]              o CHECK precisa de runtime que o GO nao usou
         [--done "<criterio> :: <comando>"]       criterio de pronto EXECUTAVEL (use ;; para varios)
         [--slug S] [--assunto A] [--worktree auto|DIR] [--dry-run]
+        [--sem-worktree]                         cria sem worktree (na branch base, o ship barra a entrega com
+                                                 push_direto_na_base: block, o padrão do ork init); com
+                                                 worktree.por_thread: true, a worktree nasce sem flag
         [--roadmap RM-NNN]                       reserva o item do roadmap antes de criar (I-47)
   thread list [--todas] [--json]            Threads NAO fechadas do projeto (--todas inclui as fechadas)
   thread close <id> --motivo orfa|engano|superada --por Q --justificativa J
@@ -277,6 +291,8 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
                                              efetivo vai ao ledger como fato verificavel)
         [--canal C] [--correlacao ID]        Canal de origem (sem ele, o que o host declara)
         [--esperar [min]]                    Com a thread ja conduzida, espera a vez (sem: recusa na hora)
+        [--perfil ID]                        Conta do despacho (ork accounts list); inexistente, de outro
+                                             runtime, esgotado ou sem login recusa com motivo tipado
   phase list <thread-id>                    Historico do ledger da thread
                                             (mostra o modelo/esforco reais de cada fase)
   ledger stats --desde 7d [--ate ISO]       Telemetria economica do ledger (intervalo [desde,ate))
@@ -284,11 +300,13 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   ledger estimate <thread-id> --sem-ia H --ia-sem-ork H --por Q --metodo M --premissas P
         [--incerteza I]                     Registra estimativas explicitas da fase PLAN
 
-  sessions [--all] [--global] [--json]      Inventário Claude e Codex da conta atual
+  sessions [--all] [--global] [--json]      Inventário Claude e Codex da conta do processo e de cada perfil
         [--exigir-limpo]                    Sai != 0 com fonte inválida ou sessão sem thread
   sessions adopt <id> [--json]             Adota identidade real sem executar prompt
   sessions event --tipo T --sessao ID       Ingere JSON limitado no stdin; observa sem aprovar gates
   sessions watch --thread T [--sessao ID]   Observa somente a sessão selecionada; --once faz uma varredura
+  sessions limpar-fantasmas [--dry-run]     Solta do ork (sessao_morta no ledger) a sessao sem pid e sem processo;
+        [--json]                             nunca toca no runtime (RM-056)
   sessions logs <sessao> [--linhas N]       Logs de uma sessao
   sessions supersede <thread> <UUID> --fase F --runtime R  Confirma encerramento de sessão superada
   sessions request <thread> <UUID> --fase F --runtime R --pergunta P  Abre pedido vinculado ao prompt nativo
@@ -378,21 +396,27 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
         [--dry-run] [--json]                     com tokens e custo estimados; --dry-run nao chama o provider
 
   grafo indexar [--verificar] [--forcar]    Indice do grafo de codigo do HEAD limpo (RM-031 KG3) no estado do projeto:
-        [--json]                                 pastas 0700, chave por revisao e extrator, idempotente; --verificar
-                                                 confere contrato, bytes e determinismo; precisa de typescript e micromark
+        [--json]                                 pastas 0700, chave por revisao e extrator, idempotente; incremental (KG4)
+                                                 a partir do indice ancestral, ou completo com o motivo; --forcar extrai
+                                                 completo; --verificar confere contrato, bytes, determinismo e o incremental
+                                                 contra a completa; precisa de typescript e micromark
   grafo status [--json]                     Indices guardados, o do HEAD, os analisadores e o tamanho
+  grafo contexto <thread> [--json]          Pacote da thread com evidencias e medida em bytes [--teto-bytes N]
   grafo vizinhos <no> [--profundidade N]    Vizinhanca de arquivo ou simbolo, com extrator e evidencia de cada aresta
         [--sentido entrada|saida|ambos] [--tipo T,...] [--limite N] [--json]
   grafo chamadores <simbolo>                Quem chama (arestas calls que chegam) [--profundidade N] [--limite N] [--json]
   grafo importadores <arquivo|simbolo>      Quem importa (arestas imports que chegam) [--profundidade N] [--limite N] [--json]
   grafo caminho <de> <para>                 Menor caminho pelas arestas [--sentido saida|entrada|ambos] [--tipo T,...] [--json]
+        [--json --teto-bytes N]                  Nas quatro consultas (KG5): JSON compacto de no maximo N bytes; as arestas mais
+                                                 longe do alvo saem ate caber, e o caminho que nao cabe recusa
   grafo amostra [--por-estrato N]           Amostra de arestas para auditoria manual; --conferir ARQ confere a auditada
   grafo limpar [--tudo] [--json]            Apaga os indices que nao sao do HEAD e as sobras com mais de uma hora
 
   ship <thread-id> --para <branch>          Merge --no-ff serializado por lease e push PROVADO
   ship registrar-pr <thread-id>|--todas    A entrega feita por PR vira ship_done: merge ship(<thread>) na base
-        [--remoto R] [--json]                    remota e CI verde no head do PR; depois, ork master --aceitar-omissao
+        [--remoto R] [--json]                    remota e CI verde no head do PR; depois, ork master <thread> --aceitar-omissao
         [--repo <dono/nome> --pr <n>]            PR mesclado em repositorio externo de ci.external_repositories
+        [--dry-run]                              Ensaio: as mesmas conferencias, sem gravar ship_done, fase nem fabrica
         [--de <branch>] [--remoto origin] [--autorizar-push <quem>] [--sem-push] [--dry-run]
 
   board [--all] [--sem-remoto]              Visao unica das threads (todos os perfis com --all); com a
@@ -420,15 +444,19 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   master batch --aceitar <thread:assinatura,...> --por <humano>
   master migrar --dry-run --por Q           Inspeciona correções sem alterar originais
   master digest <enviar|preview|responder>  Digest semanal com recibos do host
-  master <thread-id> --score 0-5 --justificativa "<texto>"
-        [--classe C[,C]] [--resumo R] [--por Q] [--refazer]
+  master <thread-id> --score 0-5 --justificativa "<texto>" --por <seu-nome>
+        [--classe C[,C]] [--resumo R] [--refazer]
                                             Fecha a thread: POSTMORTEM + MASTER log + score (so do terminal;
                                             de processo de host e recusado com master.prova-de-canal)
   master pedir <thread-id> [--formato telegram|terminal|json]
                                             Pede a nota ao dono com codigo curto; ele responde pelo Telegram
                                             (<codigo> <0 a 5> <porque>) e a nota vai ao ledger com o recibo (RM-048)
   master [--todas] [--json]                 As entregas, com o indice derivado do ledger
-  master --aceitar-omissao [--json]         Aceita as entregues por omissao, com registro
+  master <thread-id> --aceitar-omissao      Aceita por omissao SO a entrega desta thread, com registro (ou --thread T)
+        [--dry-run] [--json]                     --dry-run lista o que seria fechado, sem gravar
+  master --aceitar-omissao [--dry-run] [--json]
+                                            Aceita TODAS as entregues por omissao, listando cada uma
+                                            (de processo de agente com mais de uma, avisa em stderr)
   master classes                            As classes de falha fixas do POSTMORTEM
   licoes [--json]                           O que volta no GOAL e no PLAN da proxima thread (POSTMORTEM e
                                             MASTER) e as propostas de policy por recorrencia (I-55)
@@ -464,10 +492,19 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
                                             depois de entrar, sai sozinho ao criar thread, despachar fase,
                                             entregar e fechar, e a cada batida do pulse
   fabrica sair                              Para de publicar daqui e tira o retrato desta maquina da branch
+  network status [--json] [--sem-remoto]    A Orkastery Network desta pessoa: as maquinas, de qualquer diretorio,
+                                            com a fonte, as lacunas e o que nao foi lido (RM-053)
+  network entrar [--maquina NOME]           Esta maquina entra na rede: repositorio privado <usuario>/orkastery-network
+        [--forja github|gitlab] [--repositorio [DONO/]NOME]  na forja (criado se falta) e o primeiro retrato;
+        [--forcar]                               --forcar toma um nome que outra instalacao usa (fica no commit)
+  network publicar [--forcar] [--json]      Grava o retrato desta maquina na casa da rede (push sem forca); depois de
+                                            entrar, sai sozinho na batida do pulse e nos eventos de thread
+  network sair                              Para de publicar daqui e tira o retrato desta maquina da casa
   network roadmap [--projeto P] [--json]    Roadmap, reservas e threads de cada maquina de cada projeto, de qualquer diretorio:
         [--sem-remoto]                           fonte e hora de cada parte, lacuna tipada no que nao leu. P = caminho do clone,
                                                  github:dono/repo, gitlab:grupo/repo ou nome conhecido; sem clone, le a forja (RM-054)
-  docs verificar [--json]                   Documentacao de produto e roadmap contra o codigo e o git
+  docs verificar [--json] [--pr]            Documentacao de produto e roadmap contra o codigo e o git; no PR (--pr),
+                                            o merge de outra thread e o indice que divergem da main so avisam
                                             (padrao do dono: frontmatter, leitura, paridade; sai != 0 com erro)
   docs sincronizar [--escrever]             Fatos do ledger e do git para o roadmap (merge, fase) e indices;
                                             sem --escrever so mostra; nunca muda status por passagem de tempo
@@ -508,7 +545,9 @@ Uso: ork [--projeto <nome|caminho>] <comando> [argumentos]
   audit finding estado <id> <estado>        Carimba o achado (aberto|adiado|resolvido|descartado)
 
   thread new <nome> --from-finding <ID>     Abre a thread a partir de um achado de auditoria
-        [--modo M] [--worktree auto] [--dry-run]   (evidencia, claim e proposta viajam junto)
+        [--modo M] [--worktree auto] [--sem-worktree] [--dry-run]
+                                                 (evidencia, claim e proposta viajam junto; a worktree segue
+                                                 worktree.por_thread como no thread new)
 
 Regimes de memoria: files (fallback honesto) e orkmind (bloco B6, base propria por tenant
 declarada em memory.database_url_env pelo NOME da variavel de ambiente, sem fallback).
@@ -568,15 +607,23 @@ function comandoThread(args) {
                     return 2;
                 }
             }
-            const brutoWorktreeAchado = args.opcoes.worktree;
-            const criarWorktreeAchado = brutoWorktreeAchado === true || brutoWorktreeAchado === 'auto';
+            // P4 do ensaio da 0.5.0 (D2): a thread do achado segue a mesma regra de worktree do `thread new`.
+            let pedidoAchado;
+            try {
+                pedidoAchado = (0, thread_1.pedidoDeWorktree)({ worktree: args.opcoes.worktree, semWorktree: args.opcoes['sem-worktree'] }, carregado.manifesto.worktree.por_thread);
+            }
+            catch (e) {
+                console.error(e.message);
+                return 2;
+            }
             const r = (0, auditrun_1.abrirThreadDoAchado)(carregado, doAchado, {
                 nome: args.posicionais[2],
                 modo: modoAchado ?? undefined,
                 slug: texto(args.opcoes.slug),
                 assunto: texto(args.opcoes.assunto),
-                criarWorktree: criarWorktreeAchado,
-                worktree: criarWorktreeAchado ? null : (texto(brutoWorktreeAchado) ?? null),
+                criarWorktree: pedidoAchado.criar,
+                worktree: pedidoAchado.dir,
+                origemDaWorktree: pedidoAchado.origem,
                 dryRun: args.opcoes['dry-run'] === true,
             });
             if (!r.ok) {
@@ -601,6 +648,13 @@ function comandoThread(args) {
                 console.log((0, thread_1.resumoDaThread)(r.thread));
                 console.log('');
                 console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(r.thread.slug)}`);
+                const linhaDaWorktreeDoAchado = (0, thread_1.linhaDaWorktree)(r.worktreePor, gravadaDoAchado);
+                if (linhaDaWorktreeDoAchado)
+                    console.log(linhaDaWorktreeDoAchado);
+                const avisoDaWorktreeDoAchado = r.worktreeFalharia ? (0, thread_1.avisoDeWorktreeQueFalharia)(r.worktreeFalharia)
+                    : (0, thread_1.avisoDaWorktree)(pedidoAchado.origem, { thread: r.thread, gravada: gravadaDoAchado, worktreePor: r.worktreePor }, carregado.manifesto);
+                if (avisoDaWorktreeDoAchado)
+                    console.error(avisoDaWorktreeDoAchado);
             }
             if (r.motivo === 'claims.unverifiable') {
                 console.log('');
@@ -667,16 +721,29 @@ function comandoThread(args) {
             return { criterio, comando };
         });
         const dryRun = args.opcoes['dry-run'] === true;
-        const brutoWorktree = args.opcoes.worktree;
-        // `--worktree auto` (ou `--worktree` sozinho) cria a worktree isolada da thread;
-        // um caminho reusa um diretorio que ja existe.
-        const criarWorktree = brutoWorktree === true || brutoWorktree === 'auto';
+        // `--worktree auto` (ou `--worktree` sozinho) cria a worktree isolada da thread; um caminho reusa um
+        // diretorio que ja existe. P4 do ensaio da 0.5.0: sem flag, `worktree.por_thread: true` cria como o
+        // `--worktree auto`, e `--sem-worktree` cria sem ela. Uso invalido sai antes da reserva do roadmap.
+        let pedido;
+        try {
+            pedido = (0, thread_1.pedidoDeWorktree)({ worktree: args.opcoes.worktree, semWorktree: args.opcoes['sem-worktree'] }, carregado.manifesto.worktree.por_thread);
+        }
+        catch (e) {
+            console.error(e.message);
+            return 2;
+        }
         const brutoCiclo = texto(args.opcoes.ciclo) ?? texto(args.opcoes.variante);
         const variante = brutoCiclo ? (0, ciclos_1.parseVariante)(brutoCiclo) : null;
         if (brutoCiclo && !variante) {
             console.error(`variante de ciclo invalida: "${brutoCiclo}". Use uma de: ${Object.keys(ciclos_1.VARIANTES).join(', ')}`);
             return 2;
         }
+        // P4 do ensaio da 0.5.0 (D4, CHECK): a recusa do ciclo sai antes da reserva do roadmap, como os outros erros de
+        // uso; a do `novaThread` fica como defesa de quem o chama direto.
+        if (variante && (0, ciclos_1.definicaoDaVariante)(variante).exigeWorktree && pedido.origem === 'sem-worktree') {
+            console.error(`uso: o ciclo ${variante} exige worktree isolada: crie a thread sem --sem-worktree ou escolha outro ciclo`);
+            return 2;
+        }
         const brutoFatias = texto(args.opcoes.fatias);
         // I-47: `--roadmap RM-NNN` reserva o item ANTES de criar a thread. A reserva e o passo
         // atomico entre maquinas (o primeiro push vence); a thread e local. Se a criacao falhar,
@@ -690,8 +757,9 @@ function comandoThread(args) {
                 modo,
                 slug: texto(args.opcoes.slug),
                 assunto: texto(args.opcoes.assunto),
-                worktree: criarWorktree ? null : (texto(brutoWorktree) ?? null),
-                criarWorktree,
+                worktree: pedido.dir,
+                criarWorktree: pedido.criar,
+                origemDaWorktree: pedido.origem,
                 dryRun,
                 variante,
                 branch: texto(args.opcoes.branch),
@@ -725,14 +793,27 @@ function comandoThread(args) {
         console.log((0, thread_1.resumoDaThread)(thread));
         console.log('');
         console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(thread.slug)}`);
+        const linhaDaWorktreeNova = (0, thread_1.linhaDaWorktree)(criada.worktreePor, gravada, variante);
+        if (linhaDaWorktreeNova)
+            console.log(linhaDaWorktreeNova);
+        const avisoDaWorktreeNova = criada.worktreeFalharia ? (0, thread_1.avisoDeWorktreeQueFalharia)(criada.worktreeFalharia)
+            : (0, thread_1.avisoDaWorktree)(pedido.origem, criada, carregado.manifesto);
+        const avisoSemBase = (0, thread_1.avisoDeThreadSemBase)(thread, gravada);
         if (gravada) {
             console.log(`  estado: .orkastery/threads/${thread.id}/thread.json`);
             // Bloco B6: a origem da thread e as policies do projeto vao para a memoria
             // semantica quando ela esta ligada. Em regime files nada muda nesta saida.
             relatarPublicacao((0, memoria_1.publicar)(carregado, thread.id));
-            console.log('');
-            console.log(`Proximo passo: ork phase run ${thread.id} ${thread.faseAtual} --prompt "<pedido>"`);
+            // Thread sem base nao tem fase para rodar: o proximo passo e o do aviso.
+            if (!avisoSemBase) {
+                console.log('');
+                console.log(`Proximo passo: ork phase run ${thread.id} ${thread.faseAtual} --prompt "<pedido>"`);
+            }
         }
+        if (avisoDaWorktreeNova)
+            console.error(avisoDaWorktreeNova);
+        if (avisoSemBase)
+            console.error(avisoSemBase);
         return 0;
     }
     if (sub === 'list' || sub === undefined) {
@@ -968,7 +1049,20 @@ function comandoAccounts(args) {
         imprimir();
         return falhas > 0 ? 1 : 0;
     }
-    console.error(`subcomando desconhecido: accounts ${sub} (use list, add, remove ou check)`);
+    if (sub === 'esgotamentos') {
+        // RM-040 (B7): so leitura do registro de contas e dos ledgers dos projetos registrados.
+        let relatorio;
+        try {
+            relatorio = (0, esgotamentos_1.relatorioDeEsgotamentos)({ desde: texto(args.opcoes.desde) ?? '7d' });
+        }
+        catch (e) {
+            console.error(`${e.message} (use --desde 7d, 24h, 30m ou uma data ISO)`);
+            return 2;
+        }
+        console.log(args.opcoes.json === true ? JSON.stringify(relatorio, null, 2) : (0, esgotamentos_1.textoDosEsgotamentos)(relatorio));
+        return 0;
+    }
+    console.error(`subcomando desconhecido: accounts ${sub} (use list, add, remove, check ou esgotamentos)`);
     return 2;
 }
 function comandoSetup(args) {
@@ -1073,6 +1167,7 @@ function comandoPhase(args) {
             runtime: texto(args.opcoes.runtime),
             model: texto(args.opcoes.model),
             effort: texto(args.opcoes.effort),
+            perfil: texto(args.opcoes.perfil),
             dryRun: args.opcoes['dry-run'] === true,
             canal: conducao.canal,
             ...(conducao.correlacao ? { correlacao: conducao.correlacao } : {}),
@@ -1269,6 +1364,15 @@ function comandoSessions(args) {
         console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, sessoes_1.textoDoInventario)(r));
         return !r.ok || (args.opcoes['exigir-limpo'] === true && r.semThread > 0) ? 1 : 0;
     }
+    if (sub === 'limpar-fantasmas') {
+        if (!carregado) {
+            console.error('ork sessions limpar-fantasmas precisa de um projeto (orkastery.yaml)');
+            return 2;
+        }
+        const r = (0, sessoes_2.limparFantasmas)(raiz, { dryRun: args.opcoes['dry-run'] === true });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, sessoes_2.textoDaLimpeza)(r));
+        return r.ok ? 0 : 1;
+    }
     if (sub === 'hitl') {
         return comandoSessionsHitl(args, carregado ? raiz : '');
     }
@@ -1455,6 +1559,13 @@ function comandoClaims(args) {
             console.log('');
             console.log('AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.');
         }
+        // RM-008 (B8): a conferencia local da policy claim_sem_prova_local avisa e segue.
+        const linhasDePolicy = (0, policies_1.linhasDeAviso)(claim.avisosDePolicy ?? []);
+        if (linhasDePolicy.length) {
+            console.log('');
+            for (const l of linhasDePolicy)
+                console.log(l);
+        }
         // I-53 (RM-037, P6): o lint avisa aqui; a suite inteira e recusada no `ci prepare`.
         for (const a of claim.lint ?? []) {
             console.log('');
@@ -1533,8 +1644,14 @@ function comandoVerify(args) {
         for (const c of b.comandos) {
             console.log(`  ${c.nome.padEnd(10)} ${c.ok ? 'passava' : `ja falhava (codigo ${c.code})`}  ${c.comando}`);
         }
+        if (b.comandos.some((c) => !c.ok)) {
+            // Ensaio de 03/10 (R7): "ja falhava" sem dizer onde ver a saida do comando.
+            console.log(`  saida de quem falhou: as ultimas linhas em ${(0, thread_1.caminhoThread)(carregado.raiz, id)}, campo baseline.comandos ` +
+                `(resumo e trecho); o evento baseline_recorded esta em ork phase list ${id}`);
+        }
         if (b.comandos.length === 0) {
-            console.log('  (nenhum comando em verify: no manifesto; sem baseline nao ha como separar regressao)');
+            // Fatia 2 do ensaio da 0.5.0 (R5): a baseline foi gravada; o que falta e comando, nao baseline.
+            console.log('  (nenhum comando em verify: no manifesto: a baseline guarda so o commit, e o verify nao tem como separar regressao de divida)');
         }
         return 0;
     }
@@ -1952,23 +2069,50 @@ function comandoShip(args) {
         // RM-037 (defeito 5): PR mesclado em repositorio externo declarado em ci.external_repositories.
         const repo = texto(args.opcoes.repo), numeroDoPr = texto(args.opcoes.pr);
         if ((!alvo && args.opcoes.todas !== true) || (!!repo !== !!numeroDoPr) || (repo && !alvo)) {
-            console.error('uso: ork ship registrar-pr <thread-id> [--repo <dono/nome> --pr <n>] | --todas [--remoto R] [--json]');
+            console.error('uso: ork ship registrar-pr <thread-id> [--repo <dono/nome> --pr <n>] | --todas [--remoto R] [--json] [--dry-run]');
             return 2;
         }
-        const r = alvo && repo ? [(0, entrega_pr_1.registrarEntregaExternaPorPr)(carregado, alvo, { repositorio: repo, pr: Number(numeroDoPr) })]
-            : alvo ? [(0, entrega_pr_1.registrarEntregaPorPr)(carregado, alvo, { remoto })] : (0, entrega_pr_1.registrarEntregasPorPr)(carregado, { remoto });
+        // RM-047: o `--remoto` da linha de comando so chega ao git como nome de remoto (ship.remoto-invalido).
+        if (args.opcoes.remoto !== undefined)
+            (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
+        // RM-037 (fatia 3, defeito 6): o `--dry-run` era ignorado, e o ensaio gravava o ship_done de verdade.
+        const dryRun = args.opcoes['dry-run'] === true;
+        const r = alvo && repo ? [(0, entrega_pr_1.registrarEntregaExternaPorPr)(carregado, alvo, { repositorio: repo, pr: Number(numeroDoPr), dryRun })]
+            : alvo ? [(0, entrega_pr_1.registrarEntregaPorPr)(carregado, alvo, { remoto, dryRun })] : (0, entrega_pr_1.registrarEntregasPorPr)(carregado, { remoto, dryRun });
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r, null, 2));
             return r.some((x) => x.acao === 'recusada') ? 1 : 0;
         }
+        if (dryRun)
+            console.log('Ensaio (--dry-run): nada foi gravado.');
         if (r.length === 0)
             console.log('Nenhuma thread aberta com merge ship(<thread>) na base.');
         for (const x of r)
             console.log(`  ${x.thread.padEnd(20)} ${x.acao.padEnd(13)} ${x.motivo}`);
+        // RM-044 (A3): a pagina que o push da base vai reprovar em docs.paridade.merge, com o comando que corrige.
+        // So aviso: nada e gravado e o codigo de saida nao muda.
+        const pendentes = r.flatMap((x) => x.docsPendentes.map((d) => ({ thread: x.thread, ...d })));
+        if (pendentes.length) {
+            console.log('');
+            console.log(`Aviso: ${pendentes.length} pagina(s) do roadmap com estado.codigo fora de "Mesclado" depois do merge; o push da base reprova em docs.paridade.merge:`);
+            for (const d of pendentes) {
+                console.log(`  ${d.id} (${d.arquivo}): merge ${d.merge.slice(0, 7)} de ship(${d.thread}), estado.codigo "${d.codigo || 'vazio'}"`);
+                console.log(`    ${d.comando}   (num PR de docs sobre a base atualizada)`);
+            }
+        }
         const registradas = r.filter((x) => x.acao === 'registrou').length;
+        const registrariam = r.filter((x) => x.acao === 'registraria').length;
         if (registradas) {
             console.log('');
-            console.log(`${registradas} entrega(s) registrada(s). Fechar pelo MASTER: ork master --aceitar-omissao (a nota humana sobrescreve).`);
+            // RM-008 (03/10): o texto ensina a forma COM a thread. A forma sem thread fechava tambem as
+            // entregues de outras frentes paralelas, e era ela que os condutores copiavam daqui.
+            console.log(`${registradas} entrega(s) registrada(s). Fechar pelo MASTER so a(s) desta entrega (a nota humana sobrescreve):`);
+            for (const x of r.filter((y) => y.acao === 'registrou'))
+                console.log(`  ork master ${x.thread} --aceitar-omissao`);
+        }
+        if (registrariam) {
+            console.log('');
+            console.log(`${registrariam} entrega(s) seria(m) registrada(s). Para gravar, rode o mesmo comando sem --dry-run.`);
         }
         return r.some((x) => x.acao === 'recusada') ? 1 : 0;
     }
@@ -1978,6 +2122,10 @@ function comandoShip(args) {
         console.error('uso: ork ship <thread-id> --para <branch> [--de <branch>] [--dry-run]');
         return 2;
     }
+    // RM-047: como no registrar-pr, o `--remoto` so chega ao git como nome de remoto (ship.remoto-invalido),
+    // e `--remoto` sem valor nao vira `origin` em silencio.
+    if (args.opcoes.remoto !== undefined)
+        (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto, 'ship');
     const autorizar = args.opcoes['autorizar-push'];
     const r = (0, ship_1.ship)(carregado, id, {
         para,
@@ -2172,10 +2320,15 @@ function comandoCi(args) {
     if (sub === 'status') {
         const sha = texto(args.opcoes.sha) ?? args.posicionais[2] ?? (0, util_1.exec)('git', ['rev-parse', 'HEAD'], carregado.raiz).stdout.trim();
         if (!/^[0-9a-f]{40}$/.test(sha)) {
-            console.error('uso: ork ci status --sha <commit> [--remoto origin]');
+            // Ensaio de 03/10 (R4): `--sha HEAD` ou um sha curto respondiam so a linha de uso, sem dizer por que.
+            console.error('erro: ci status: --sha exige o sha completo, de 40 caracteres hexadecimais minusculos ' +
+                '(git rev-parse HEAD); o check e consultado no commit exato, nunca por ref nem prefixo');
+            console.error('uso: ork ci status --sha <sha de 40 caracteres> [--remoto origin]');
             return 2;
         }
-        const result = (0, ci_1.consultarCi)(carregado, sha, texto(args.opcoes.remoto) ?? 'origin');
+        // RM-047: recusa o `--remoto` que nao e nome de remoto mesmo com o gate de CI desligado.
+        const remoto = (0, branch_de_estado_1.exigirRemoto)(args.opcoes.remoto === undefined ? 'origin' : args.opcoes.remoto, 'ci');
+        const result = (0, ci_1.consultarCi)(carregado, sha, remoto);
         console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : `${result.ok ? 'CI VERDE' : 'CI NÃO LIBEROU'}: ${result.detail}`);
         return result.ok ? 0 : 1;
     }
@@ -2302,7 +2455,11 @@ const CONTRATO_DO_BOARD = 'ork.board/v1';
 function comandoFabrica(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    // RM-047: o remoto vem do manifesto de quem fez o repositorio; fora do formato, recusa antes do git.
+    // O `publicar` recusa dentro do try (publicarMaquina), para o silencioso deixar a recusa no log.
     const remoto = texto(args.opcoes.remoto) ?? carregado.manifesto.fabrica.remoto;
+    if (sub !== 'publicar')
+        (0, branch_de_estado_1.exigirRemoto)(remoto, 'fabrica');
     if (sub === 'publicar') {
         const silencioso = args.opcoes.silencioso === true;
         try {
@@ -2373,7 +2530,8 @@ function comandoFabrica(args) {
         naoLido: [projeto_alvo_1.FORA_DA_CONSULTA.roadmap, projeto_alvo_1.FORA_DA_CONSULTA.reservas, ...(url === null ? [(0, projeto_alvo_1.semRemoto)(remoto)] : [])],
     });
     if (args.opcoes.json === true) {
-        console.log(JSON.stringify({ ...painel, consulta }, null, 2));
+        // RM-053 (fatia 2): o mesmo JSON, com o invisivel do remoto escrito como \uXXXX.
+        console.log((0, saida_segura_1.jsonSemInvisivel)({ ...painel, consulta }));
         return 0;
     }
     console.log([...(0, projeto_alvo_1.linhasDaConsulta)(consulta), ''].join('\n'));
@@ -2382,6 +2540,94 @@ function comandoFabrica(args) {
         : (0, fabrica_estado_1.textoDaFabrica)(painel, (0, maquina_1.nomeDaMaquina)()));
     return 0;
 }
+/**
+ * RM-053: `ork network` e a Orkastery Network, as maquinas de uma pessoa em rede. Roda de qualquer
+ * diretorio, com ou sem projeto: a rede e da pessoa, nao de um repositorio. O projeto do diretorio
+ * atual, quando ha, so entra no retrato e na leitura da fabrica legada.
+ */
+function comandoNetwork(args) {
+    const sub = args.posicionais[1];
+    // RM-054: `network roadmap` tem o proprio --projeto e o proprio uso.
+    if (sub === 'roadmap')
+        return comandoNetworkRoadmap(args);
+    const diretorio = process.cwd();
+    const uso = 'uso: ork network [status] [--json] [--sem-remoto] | network entrar [--maquina NOME] [--forja github|gitlab] ' +
+        '[--repositorio [DONO/]NOME] [--forcar] | network publicar [--forcar] [--json] | network sair | ' +
+        'network roadmap [--projeto P] [--json] [--sem-remoto]';
+    const forja = texto(args.opcoes.forja), repositorio = texto(args.opcoes.repositorio);
+    if ((args.opcoes.forja !== undefined && !(0, rede_forja_1.ehNomeDeForja)(forja)) || args.opcoes.repositorio === true ||
+        (repositorio !== undefined && !/^(?:[A-Za-z0-9][A-Za-z0-9._-]{0,99}\/)?[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repositorio))) {
+        console.error(uso);
+        return 2;
+    }
+    if (sub === 'entrar') {
+        const r = (0, rede_1.entrarNaRede)({ maquina: texto(args.opcoes.maquina), forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio, diretorio,
+            tomarNome: args.opcoes.forcar === true });
+        console.log(`Rede: ${r.publicacao.maquina} entrou na Orkastery Network de ${r.casa.dono} (${r.casa.forja}: ${(0, rede_1.refDaCasa)(r.casa)}, ` +
+            `privado${r.criado ? ', criado agora' : ''}).`);
+        console.log(`  Primeiro retrato publicado (${r.publicacao.commit?.slice(0, 7)}). Depois, esta maquina publica sozinha na batida do pulse`);
+        if (r.publicacao.tomouNome)
+            console.log(`  Tomou o nome "${r.publicacao.maquina}" de outra instalacao; o commit registra.`);
+        console.log('  e ao criar thread, despachar fase, entregar e fechar. De qualquer maquina desta pessoa: ork network status');
+        for (const d of r.publicacao.descartados) {
+            console.log(`  AVISO: um projeto ficou fora do retrato: padrao "${d.padrao}" em ${d.campo} (valor omitido de proposito).`);
+        }
+        if (process.env.ORK_MAQUINA && process.env.ORK_MAQUINA.trim() !== r.publicacao.maquina) {
+            console.log(`  AVISO: ORK_MAQUINA=${process.env.ORK_MAQUINA} neste shell vence o nome gravado; alinhe os dois.`);
+        }
+        return 0;
+    }
+    if (sub === 'sair') {
+        const r = (0, rede_1.sairDaRede)({ forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio });
+        console.log(`Rede: ${r.maquina} saiu; nada mais e publicado daqui.` + (r.commit
+            ? ` Retrato removido de ${r.casa} (${r.commit.slice(0, 7)}).`
+            : r.alheio
+                ? ` O retrato "${r.maquina}" em ${r.casa} e de outra instalacao com o mesmo nome; nada foi removido.` +
+                    (r.mesmoHostname ? ' Ele tem o hostname desta maquina: se ~/.orkastery foi apagada, retome o nome com ork network entrar --forcar.' : '')
+                : ` Nao havia retrato desta maquina${r.casa ? ` em ${r.casa}` : ' numa casa alcancavel'}.`));
+        if ((0, maquina_1.lerConfigDaMaquina)()?.fabricaCompartilhada) {
+            console.log('  A fabrica compartilhada dos projetos continua publicando daqui (ork/fabrica-estado); ork fabrica sair em cada um para parar.');
+        }
+        return 0;
+    }
+    if (sub === 'publicar') {
+        if (args.opcoes.silencioso === true) {
+            // O filho do evento de thread: quem disparou ja tomou a vez (teto de 14 min) e nao espera.
+            try {
+                (0, rede_adesao_1.registrarNaRede)({ ...(0, rede_1.publicarRede)({ diretorio }), origem: 'evento' });
+                return 0;
+            }
+            catch (e) {
+                (0, rede_adesao_1.registrarNaRede)({ acao: 'falhou', origem: 'evento', erro: e.message });
+                return 1;
+            }
+        }
+        const r = (0, rede_1.publicarRede)({ diretorio, forcar: args.opcoes.forcar === true, forja: (0, rede_forja_1.ehNomeDeForja)(forja) ? forja : undefined, repositorio });
+        if (args.opcoes.json === true)
+            console.log(JSON.stringify(r, null, 2));
+        else
+            console.log(r.acao === 'publicou'
+                ? `Rede: ${r.maquina} publicou o retrato em ${r.casa} (${r.commit?.slice(0, 7)}, ${r.tentativas} tentativa(s)).`
+                : r.acao === 'ocupado'
+                    ? 'Rede: outra publicacao desta maquina esta em andamento; tente de novo em instantes.'
+                    : `Rede: retrato de ${r.maquina} igual ao ultimo publicado em ${r.casa}; nada a enviar (use --forcar para publicar mesmo assim).`);
+        if (args.opcoes.json !== true) {
+            for (const d of r.descartados)
+                console.log(`  AVISO: um projeto ficou fora do retrato: padrao "${d.padrao}" em ${d.campo} (valor omitido de proposito).`);
+        }
+        return 0;
+    }
+    if (sub !== undefined && sub !== 'status') {
+        console.error(`subcomando desconhecido: network ${sub}`);
+        console.error(uso);
+        return 2;
+    }
+    // RM-054 (fatia 3): o host sem cwd de projeto (RM-052, D3) nao faz do diretorio do gateway um projeto lido.
+    const doHost = (process.env[projeto_alvo_1.ENV_PROJETO_EXPLICITO] ?? '').trim() === '1';
+    const status = (0, rede_status_1.lerRede)({ semRemoto: args.opcoes['sem-remoto'] === true, diretorio: doHost ? null : diretorio });
+    console.log(args.opcoes.json === true ? (0, rede_status_1.jsonDaRede)(status) : (0, rede_status_1.textoDaRede)(status));
+    return 0;
+}
 /**
  * RM-052: `ork projetos` lista o registro desta maquina (`~/.orkastery/projetos.json`); `registrar`
  * poe uma copia que ja existia antes do registro (init, thread new e fabrica entrar ja registram) e
@@ -2618,26 +2864,13 @@ function comandoMaster(args) {
         console.error('master.fila-aposentada: a fila de ratificacao de score saiu na I-43. ' +
             'Entregue e aceito, a menos que voce diga o contrario.\n' +
             '  ork master                     as entregas, com o indice ja derivado do ledger\n' +
-            '  ork master --aceitar-omissao   aceita as entregues, com indice e insumos no ledger\n' +
+            '  ork master <id> --aceitar-omissao   aceita so esta entrega, com indice e insumos no ledger\n' +
+            '  ork master --aceitar-omissao        aceita todas as entregues (--dry-run mostra quais)\n' +
             '  ork master <id> --score <0-5> --justificativa "<por que>" --por <humano>   para reclamar');
         return 2;
     }
-    if (args.opcoes['aceitar-omissao'] === true) {
-        const aceitos = (0, master_2.aceitarPendentesPorOmissao)(carregado.raiz);
-        if (args.opcoes.json === true) {
-            console.log(JSON.stringify(aceitos, null, 2));
-            return 0;
-        }
-        if (aceitos.length === 0) {
-            console.log('Nenhuma entrega esperando decisao.');
-            return 0;
-        }
-        console.log(`Aceitas por omissao: ${aceitos.length}. O indice e os insumos foram ao ledger.`);
-        for (const a of aceitos)
-            console.log(`  ${a.thread.padEnd(20)} indice ${a.indice.valor}/${a.indice.base}`);
-        console.log('');
-        console.log('Discordou? A nota humana sobrescreve, e o registro da omissao permanece.');
-        return 0;
+    if (args.opcoes['aceitar-omissao'] !== undefined) {
+        return comandoAceitarOmissao(args, carregado.raiz, primeiro);
     }
     if (primeiro === undefined) {
         console.log(args.opcoes.json
@@ -2653,7 +2886,7 @@ function comandoMaster(args) {
     const brutoScore = texto(args.opcoes.score);
     const justificativa = texto(args.opcoes.justificativa) ?? texto(args.opcoes.porque);
     if (brutoScore === undefined) {
-        console.error('uso: ork master <thread-id> --score 0-5 --justificativa "<texto>"');
+        console.error('uso: ork master <thread-id> --score 0-5 --justificativa "<texto>" --por <seu-nome>');
         console.error('  o score do MASTER e humano, de 0 a 5, e a justificativa e obrigatoria.');
         return 2;
     }
@@ -2705,6 +2938,88 @@ function comandoMaster(args) {
     console.log(`Proximo passo: ork board --all   |   entregas e indice: ork master`);
     return 0;
 }
+/**
+ * RM-008 (03/10/2026): `ork master [<thread>] --aceitar-omissao [--thread T] [--dry-run] [--json]`.
+ *
+ * Tres vezes na madrugada de 03/10, um condutor rodou `ork master --aceitar-omissao` para fechar a
+ * propria thread, e o comando fechou tambem as entregues de outras frentes (ork-rm057fatia3t,
+ * ork-rm025modocon). A thread indicada (posicional, `--thread T` ou `--aceitar-omissao=T`) limita o
+ * aceite a ela. Sem thread, o padrao continua o mesmo, por decisao registrada: drenar todas, agora
+ * listando cada uma e avisando em stderr quando quem roda e processo de agente.
+ */
+function comandoAceitarOmissao(args, raiz, posicional) {
+    const bruto = args.opcoes['aceitar-omissao'];
+    const candidatos = [posicional, texto(args.opcoes.thread), typeof bruto === 'string' ? bruto : undefined]
+        .filter((v) => typeof v === 'string' && v.trim() !== '').map((v) => v.trim());
+    if (args.opcoes.thread === true || new Set(candidatos).size > 1) {
+        console.error('uso: ork master <thread-id> --aceitar-omissao [--dry-run] [--json]   (ou --thread <thread-id>, uma thread so)');
+        return 2;
+    }
+    const alvo = candidatos[0];
+    const dryRun = args.opcoes['dry-run'] === true;
+    const json = args.opcoes.json === true;
+    if (alvo) {
+        const fora = (0, master_2.motivoForaDaOmissao)(raiz, alvo);
+        if (fora) {
+            if (json)
+                console.log(JSON.stringify(dryRun ? { dryRun: true, fecharia: [], motivo: fora.motivo } : [], null, 2));
+            else
+                (fora.motivo === 'ja-fechada' ? console.log : console.error)(fora.texto);
+            return fora.motivo === 'ja-fechada' ? 0 : 1;
+        }
+    }
+    if (dryRun) {
+        const fecharia = (0, master_2.entregasParaOmissao)(raiz, alvo).map((p) => ({ thread: p.thread.id, indice: (0, master_2.indiceDaThread)(raiz, p.thread.id) }));
+        if (json) {
+            console.log(JSON.stringify({ dryRun: true, fecharia }, null, 2));
+            return 0;
+        }
+        console.log('Ensaio (--dry-run): nada foi gravado.');
+        if (fecharia.length === 0) {
+            console.log('Nenhuma entrega esperando decisao.');
+            return 0;
+        }
+        console.log(`Fecharia por omissao: ${fecharia.length}.`);
+        for (const f of fecharia)
+            console.log(`  ${f.thread.padEnd(20)} indice ${f.indice.valor}/${f.indice.base}`);
+        avisoDeOmissaoSemAlvo(alvo, fecharia.length, true);
+        return 0;
+    }
+    const aceitos = (0, master_2.aceitarPendentesPorOmissao)(raiz, { thread: alvo });
+    avisoDeOmissaoSemAlvo(alvo, aceitos.length, false);
+    if (json) {
+        console.log(JSON.stringify(aceitos, null, 2));
+        return 0;
+    }
+    if (aceitos.length === 0) {
+        console.log('Nenhuma entrega esperando decisao.');
+        return 0;
+    }
+    console.log(`Aceitas por omissao: ${aceitos.length}. O indice e os insumos foram ao ledger.`);
+    for (const a of aceitos)
+        console.log(`  ${a.thread.padEnd(20)} indice ${a.indice.valor}/${a.indice.base}`);
+    console.log('');
+    console.log('Discordou? A nota humana sobrescreve, e o registro da omissao permanece.');
+    return 0;
+}
+/**
+ * O aviso do aceite SEM thread vindo de processo de agente que alcanca mais de uma entrega. A marca
+ * e a mesma do `master.prova-de-canal` (ambiente do host ou do despacho). Vai para stderr: o stdout,
+ * inclusive o `--json`, fica como era.
+ */
+function avisoDeOmissaoSemAlvo(alvo, quantas, ensaio) {
+    if (alvo || quantas <= 1)
+        return;
+    const marca = (0, master_nota_1.marcaDeHost)(process.env);
+    if (!marca)
+        return;
+    const propria = (process.env[runtime_ambiente_1.ENV_THREAD_DO_DESPACHO] ?? '').trim();
+    console.error('');
+    console.error(`aviso: master.omissao-sem-thread: processo de agente (${marca}) ${ensaio ? 'fecharia' : 'fechou'} ${quantas} threads, ` +
+        'inclusive as de outras frentes paralelas.');
+    console.error(`  Para fechar so a sua: ork master ${propria || '<thread-id>'} --aceitar-omissao` +
+        (ensaio ? '' : '  (a nota humana sobrescreve o aceite de quem nao era seu)'));
+}
 /** I-55 (RM-008): `ork licoes` mostra o que volta no proximo GOAL e PLAN, e as propostas de policy. */
 function comandoLicoes(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
@@ -2802,7 +3117,7 @@ function comandoRoadmap(args) {
  * RM-054 (fatia 1): `ork network roadmap`, o roadmap da rede de qualquer diretorio. Pedido de projeto
  * ambiguo ou desconhecido e resposta, nao erro: a recusa com os candidatos, e o codigo da RM-052.
  */
-function comandoNetwork(args) {
+function comandoNetworkRoadmap(args) {
     const pedido = texto(args.opcoes.projeto);
     if (args.posicionais[1] !== 'roadmap' || args.posicionais.length > 2 || (args.opcoes.projeto !== undefined && !pedido)) {
         console.error('uso: ork network roadmap [--projeto <caminho|github:dono/repo|gitlab:grupo/repo|nome>] [--json] [--sem-remoto]');
@@ -2829,7 +3144,8 @@ function comandoDocs(args) {
     const raiz = carregado?.raiz ?? (0, manifest_1.diretorioDoProjeto)();
     const baseBranch = carregado?.manifesto.worktree?.base_branch ?? 'main';
     if (sub === 'verificar') {
-        const { docs, achados } = (0, docs_1.verificarDocs)(raiz, { baseBranch, ajudaDoCli: AJUDA });
+        // RM-037 (fatia 3, GO-FIX 2): o CI passa --pr no pull_request; no push da main as duas regras novas reprovam.
+        const { docs, achados } = (0, docs_1.verificarDocs)(raiz, { baseBranch, ajudaDoCli: AJUDA, pr: args.opcoes.pr === true });
         if (args.opcoes.json === true) {
             console.log(JSON.stringify({ paginas: docs.length, erros: achados.filter((a) => a.gravidade === 'erro').length,
                 achados }, null, 2));
@@ -2881,7 +3197,7 @@ function comandoDocs(args) {
                 'Proximo passo: copie docs/produto/_modelo-feature.md e docs/roadmap/_modelo-item.md, e rode ork docs verificar'].join('\n'));
         return 0;
     }
-    console.error(`uso: ork docs verificar [--json] | sincronizar [--escrever] [--so RM-NNN] [--todos] | init`);
+    console.error(`uso: ork docs verificar [--json] [--pr] | sincronizar [--escrever] [--so RM-NNN] [--todos] | init`);
     return 2;
 }
 function comandoPrompt(args) {
@@ -2958,6 +3274,19 @@ function exigirFaseCanonica(bruto) {
 /**
  * `ork adapter list|show|install <host>`: instalacao dos adaptadores de Camada 1 (bloco B4).
  */
+/**
+ * O caminho real do `ork` em execução, quando o processo é este CLI (argv[1] resolve para este arquivo).
+ * Importado por outro script, devolve undefined e o install volta à ordem antiga (PATH, catálogo).
+ */
+function orkEmExecucao() {
+    try {
+        const proprio = fs.realpathSync(__filename);
+        return process.argv[1] && fs.realpathSync(process.argv[1]) === proprio ? proprio : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function comandoAdapter(args) {
     const sub = args.posicionais[1] ?? 'list';
     if (sub === 'list') {
@@ -2991,6 +3320,8 @@ function comandoAdapter(args) {
             dryRun: args.opcoes['dry-run'] === true,
             force: args.opcoes.force === true || args.opcoes.forcar === true,
             orkBin: texto(args.opcoes.ork),
+            // Ensaio de 03/10: a extensão chama o ork que a instalou, não o primeiro do PATH.
+            orkEmExecucao: orkEmExecucao(),
             versao: VERSAO,
             // I-43 (D5): a decisao por ARQUIVO, que e o que faz `--force` deixar de ser o
             // unico caminho de saida. `;` separa varios, como o resto do CLI ja faz.
@@ -3627,7 +3958,20 @@ function comandoMemory(args) {
         const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
         const driver = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
         const embedder = new orkmind_1.DriverCliOrkMind(driver);
-        const universo = (0, indice_vetorial_1.universoDoTenant)(memoria, memoria.estado.tenant);
+        // RM-038: o universo da busca inteiro, numa leitura; sem ele, nada e embedado (nunca um pedaco).
+        let universo;
+        try {
+            universo = (0, indice_vetorial_1.universoDaBusca)(memoria, memoria.estado.tenant);
+        }
+        catch (erro) {
+            const motivo = (0, indice_vetorial_1.codigoDaFalha)(erro);
+            const detalhe = 'o universo da busca nao foi lido inteiro; nada foi embedado';
+            if (args.opcoes.json === true)
+                console.log(JSON.stringify({ motivo, detalhe }, null, 2));
+            else
+                console.error(`memory.index: ${motivo}; ${detalhe}`);
+            return 1;
+        }
         const alvos = modelo === 'todos' ? ['primario', 'fallback'] : [modelo];
         const resultados = alvos.map(alvo => (0, indice_vetorial_1.indexar)({ raiz: carregado.raiz, tenant: memoria.estado.tenant,
             dsn: driver.dsn, config, alvo, universo, dryRun: args.opcoes['dry-run'] === true,
@@ -3640,7 +3984,7 @@ function comandoMemory(args) {
         }
         else {
             for (const r of resultados)
-                console.log(textoDoIndice(r));
+                console.log((0, indice_vetorial_1.textoDoIndice)(r));
         }
         return resultados.some(r => !r.dryRun && r.motivo) ? 1 : 0;
     }
@@ -3678,51 +4022,43 @@ function buscaPorTexto(args, carregado) {
     const memoria = (0, memoria_1.abrirMemoria)(carregado);
     const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
     let r;
+    const vazio = { texto: frase, modo, origem: 'nenhum', modeloUsado: null, deterministico: false,
+        resultados: [], listas: { vetor: [], fts: [] }, ftsForaDoUniverso: 0, coberturaDoIndice: null };
+    let universo = null;
+    let falhaDoUniverso = '';
+    if (memoria.ativo) {
+        try {
+            universo = (0, indice_vetorial_1.universoDaBusca)(memoria, memoria.estado.tenant);
+        }
+        catch (erro) {
+            falhaDoUniverso = (0, indice_vetorial_1.codigoDaFalha)(erro);
+        }
+    }
     if (!memoria.ativo) {
-        r = { texto: frase, modo, origem: 'nenhum', modeloUsado: null, deterministico: false, motivo: memoria.estado.motivo,
-            detalhe: `${memoria.estado.detalhe}; correcao: ${memoria.estado.correcao}`, resultados: [], listas: { vetor: [], fts: [] } };
+        r = { ...vazio, motivo: memoria.estado.motivo, detalhe: `${memoria.estado.detalhe}; correcao: ${memoria.estado.correcao}` };
+    }
+    else if (!universo) {
+        // RM-038: sem o universo inteiro nao ha busca; o motivo tipado sai, nunca um resultado parcial.
+        r = { ...vazio, motivo: falhaDoUniverso, detalhe: 'o universo da busca nao foi lido inteiro; nada foi buscado' };
     }
     else {
         const driver = (0, orkmind_1.configDoManifesto)(carregado.manifesto);
         const transporte = new orkmind_1.DriverCliOrkMind(driver);
         const fallback = memoria.estado.embeddings?.fallback;
         r = (0, busca_semantica_1.buscarPorSignificado)({ raiz: carregado.raiz, tenant: memoria.estado.tenant, dsn: driver.dsn, config,
-            universo: (0, indice_vetorial_1.universoDoTenant)(memoria, memoria.estado.tenant, colecao ? [colecao] : orkmind_1.COLECOES_DO_ORK),
+            universo, colecao: colecao,
             texto: frase, modo, limite, timeoutMs: driver.timeoutMs,
             chavePresente: memoria.estado.embeddings?.chavePresente === true,
             fallbackUsavel: memoria.estado.embeddings?.sondado === true && fallback?.dependencias === true,
             embeddar: (p, o) => transporte.embeddar(p, o), buscarTexto: (t, q) => transporte.buscarTexto(t, q) });
     }
+    const codigo = universo ? 0 : 1;
     if (args.opcoes.json === true) {
         console.log(JSON.stringify(r, null, 2));
-        return 0;
+        return codigo;
     }
-    console.log(`Busca por significado (NAO deterministica; modo ${r.modo}, origem ${r.origem}${r.modeloUsado ? ` ${r.modeloUsado}` : ''})`);
-    if (r.motivo)
-        console.log(`  motivo: ${r.motivo}${r.detalhe ? `; ${r.detalhe}` : ''}`);
-    console.log('');
-    r.resultados.forEach((e, i) => {
-        const sim = e.similaridade === null ? '' : `  similaridade ${e.similaridade}`;
-        console.log(`  ${i + 1}. [${e.collection}] ${e.id}  score ${e.score}  ${e.fontes.join('+')}${sim}`);
-        console.log(`      ${e.resumo}`);
-    });
-    console.log('');
-    console.log(`  ${r.resultados.length} resultado(s); busca por tag continua em ork memory search --tags`);
-    return 0;
-}
-/** Texto de `ork memory index`: o que foi (ou seria) embedado e quanto custa estimado. */
-function textoDoIndice(r) {
-    const custo = r.custoEstimadoUsd === null ? 'nao estimado' : `US$ ${r.custoEstimadoUsd.toFixed(8)}`;
-    return [
-        `Indice vetorial (${r.alvo}${r.dryRun ? ', --dry-run' : ''}): ${r.modelo ?? '(sem modelo)'}${r.dim ? ` / ${r.dim} dim` : ''}`,
-        `  universo do tenant   ${r.universo} entrada(s); coerentes ${r.coerentes}`,
-        `  embedados            ${r.embedados} (reescritos ${r.reescritos}); removidos ${r.removidos}`,
-        `  fora do indice       ${r.recusados} recusada(s) por padrao de segredo, ${r.foraDoLimite} acima do limite`,
-        ...(r.truncados ? [`  truncados            ${r.truncados} acima do contexto do modelo local, embedados pelo comeco`] : []),
-        `  estimativa           ${r.tokensEstimados} token(s), ${custo}; chamadas ao provider ${r.chamadasAoProvider}`,
-        ...(r.arquivo ? [`  arquivo              ${r.arquivo}`] : []),
-        ...(r.motivo ? [`  motivo               ${r.motivo}: ${r.detalhe}`] : r.detalhe ? [`  ${r.detalhe}`] : []),
-    ].join('\n');
+    console.log((0, busca_semantica_1.textoDaBuscaPorSignificado)(r));
+    return codigo;
 }
 /**
  * RM-052: `--projeto <nome|caminho>` e opcao GLOBAL. Sai do argv em qualquer posicao, antes de
@@ -3873,11 +4209,13 @@ function main(argvBruto) {
                 console.log((0, preflight_1.textoPreflight)(r));
                 return r.prontoPrimeiroBloco ? 0 : 1;
             }
-            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados);
+            // RM-031: o check dos analisadores do grafo entra por aqui, a porta da familia do grafo (fronteira do KG1).
+            const r = (0, doctor_1.doctor)((0, manifest_1.diretorioDoProjeto)(), nomesHerdados, () => (0, intelligence_graph_cli_1.checarAnalisadoresDoGrafo)(versao_1.VERSAO_DO_ORK));
             console.log(r.texto);
             return r.codigo;
         }
         case 'init': {
+            (0, init_1.exigirRepositorioParaInit)(process.cwd());
             const r = (0, init_1.init)(process.cwd(), {
                 force: args.opcoes.force === true,
                 nome: texto(args.opcoes.name) ?? texto(args.opcoes.nome),
@@ -3901,6 +4239,9 @@ function main(argvBruto) {
             console.log(`  gerenciador ${r.deteccao.gerenciador}`);
             console.log(`  verify      ${Object.entries(r.deteccao.verify).map(([k, v]) => `${k}="${v}"`).join(', ') || '(nenhum script detectado)'}`);
             console.log(`  AGENTS.md   ${agents.estado}: ${agents.caminho}`);
+            // Fatia 2 do ensaio da 0.5.0 (P3): o estado fica fora do git por um `.gitignore` proprio.
+            if (r.estadoIgnorado)
+                console.log(`  estado      ${manifest_1.DIR_ESTADO}/ fora do git (${manifest_1.DIR_ESTADO}/.gitignore com *; o seu .gitignore fica como está)`);
             console.log('');
             console.log(init_2.PROXIMO_PASSO_INIT);
             return 0;
@@ -3976,7 +4317,9 @@ function main(argvBruto) {
             // Preferência inválida vale o padrão e faz o adapter install pular o pacote: a consulta avisa.
             const avisos = manifesto.avisos.filter(a => a.startsWith('experiencia.config.invalid'));
             console.log(args.opcoes.json ? JSON.stringify({ ...p, avisos }, null, 2) :
-                `Experiência ${p.experience ? 'ativa' : 'desativada'}: ${p.language}, ${p.timezone}, profundidade ${p.depth}.\nSkill: ${p.skill}\nOrigens: ${JSON.stringify(p.origem)}` +
+                `Experiência ${p.experience ? 'ativa' : 'desativada'}: ${p.language}, ${p.timezone}, profundidade ${p.depth}.\nSkill: ${p.skill}\n` +
+                    // Fatia 2 do ensaio da 0.5.0 (R2): as origens em texto, e nao o JSON cru.
+                    `Origens: ${Object.entries(p.origem).map(([chave, origem]) => `${chave} ${origem}`).join(', ')}` +
                     avisos.map(a => `\nAviso: ${a}; o adapter install pula o pacote até ork onboarding set maestro corrigir.`).join(''));
             return 0;
         }
@@ -4047,7 +4390,9 @@ function main(argvBruto) {
         case 'grafo': {
             // RM-031 KG3 (D7): o argv cru depois do comando; o parser do grafo e estrito.
             const carregado = (0, manifest_1.exigirManifesto)();
-            return (0, intelligence_graph_cli_1.executarGrafo)(argv.slice(argv.indexOf('grafo') + 1), { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name, escrever: (texto) => console.log(texto) });
+            return (0, intelligence_graph_cli_1.executarGrafo)(argv.slice(argv.indexOf('grafo') + 1), { raiz: carregado.raiz, estado: (0, estado_thread_1.raizDoEstado)(carregado.raiz), repositorio: carregado.manifesto.project.name, versao: versao_1.VERSAO_DO_ORK,
+                contextoDaThread: (id) => (0, mcp_grafo_1.lerEntradaDaThread)(carregado.raiz, id),
+                escrever: (texto) => console.log(texto) });
         }
         case 'ship':
             return comandoShip(args);