@orkastery/cli 0.2.0 → 0.4.1

package/dist/index.js

@@ -1,5 +1,59 @@
 #!/usr/bin/env node
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseArgs = parseArgs;
+exports.main = main;
+const company_brain_cli_1 = require("./company-brain-cli");
+const maestro_cli_1 = require("./maestro-cli");
+const hitl_public_receipt_1 = require("./hitl-public-receipt");
+const hitl_presentation_1 = require("./hitl-presentation");
+const hitl_native_offer_1 = require("./hitl-native-offer");
+const hitl_ingress_receipt_1 = require("./hitl-ingress-receipt");
+const node_path_1 = require("node:path");
+const project_state_1 = require("./project-state");
+const hitl_sessions_1 = require("./hitl-sessions");
+const write_activation_1 = require("./write-activation");
+const escopo_escrita_1 = require("./escopo-escrita");
+const node_os_1 = require("node:os");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const creation_operation_1 = require("./creation-operation");
+const creation_operation_store_1 = require("./creation-operation-store");
+const portfolio_context_1 = require("./portfolio-context");
 /**
  * `ork`: nucleo CLI deterministico do Orkastery (bloco B0).
  *
@@ -7,45 +61,90 @@
  * mundo real e registra no ledger. Quem escreve codigo e a orquestra (Camada 3);
  * quem decide e o humano; o meio e conduzido por software.
  */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseArgs = parseArgs;
-exports.main = main;
+const thread_close_1 = require("./thread-close");
+const session_events_1 = require("./session-events");
+const session_watcher_1 = require("./session-watcher");
+const master_migracao_1 = require("./master-migracao");
+const master_batch_1 = require("./master-batch");
+const master_digest_1 = require("./master-digest");
+const master_audit_1 = require("./master-audit");
+const process_audit_1 = require("./process-audit");
+const master_1 = require("./master");
 const auditoria_1 = require("./auditoria");
 const auditrun_1 = require("./auditrun");
 const superficie_1 = require("./superficie");
 const board_1 = require("./board");
+const hitl_1 = require("./hitl");
+const pulse_1 = require("./pulse");
+const pulse_resposta_1 = require("./pulse-resposta");
+const pulse_cadencia_1 = require("./pulse-cadencia");
+const decisao_autonoma_1 = require("./decisao-autonoma");
 const orquestracao_1 = require("./orquestracao");
 const divida_1 = require("./divida");
 const ciclos_1 = require("./ciclos");
 const claims_1 = require("./claims");
 const catalogo_1 = require("./catalogo");
 const doctor_1 = require("./doctor");
+const preflight_1 = require("./preflight");
 const evalrunner_1 = require("./evalrunner");
 const gates_1 = require("./gates");
+const hitl_gates_1 = require("./hitl-gates");
 const handoff_1 = require("./handoff");
 const hosts_1 = require("./hosts");
 const init_1 = require("./init");
+const portfolio_1 = require("./portfolio");
+const agents_md_1 = require("./agents-md");
 const leases_1 = require("./leases");
-const master_1 = require("./master");
+const sessoes_inventario_1 = require("./sessoes-inventario");
+const ledger_stats_1 = require("./ledger-stats");
+const sessoes_adopt_1 = require("./sessoes-adopt");
+const sessoes_1 = require("./sessoes");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const policies_1 = require("./policies");
+const master_2 = require("./master");
 const manifest_1 = require("./manifest");
+const horario_1 = require("./horario");
+const onboarding_1 = require("./onboarding");
+const init_2 = require("./init");
 const memoria_1 = require("./memoria");
+const orkmind_1 = require("./orkmind");
 const recall_1 = require("./recall");
+const memory_migration_1 = require("./memory-migration");
 const fix_1 = require("./fix");
 const ratelimit_1 = require("./ratelimit");
 const retry_1 = require("./retry");
+const prova_minima_1 = require("./prova-minima");
+const versao_1 = require("./versao");
 const modos_1 = require("./modos");
+const modos_migracao_1 = require("./modos-migracao");
+const setup_1 = require("./setup");
+const runtime_profiles_1 = require("./runtime-profiles");
+const claude_bg_1 = require("./adapters/claude-bg");
+const codex_1 = require("./adapters/codex");
+const conducao_1 = require("./conducao");
 const phase_1 = require("./phase");
 const prompts_1 = require("./prompts");
-const sessoes_1 = require("./sessoes");
+const sessoes_2 = require("./sessoes");
 const util_1 = require("./util");
 const ship_1 = require("./ship");
+const ci_1 = require("./ci");
 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 fabrica_publicar_1 = require("./fabrica-publicar");
+const maquina_1 = require("./maquina");
+const ledger_1 = require("./ledger");
 const tokens_1 = require("./tokens");
 const types_1 = require("./types");
 const verify_1 = require("./verify");
 const worktree_1 = require("./worktree");
-/** A versao publicada em `@orkastery/cli`. Anda junto com o `version` do package.json. */
-const VERSAO = '0.2.0';
+const claim_lint_1 = require("./claim-lint");
+const licoes_1 = require("./licoes");
+const demo_1 = require("./demo");
+const entrega_pr_1 = require("./entrega-pr");
+/** A versao publicada em `@orkastery/cli`, lida do package.json (`versao.ts`). */
+const VERSAO = versao_1.VERSAO_DO_ORK;
 /** Parse simples de argumentos: `--chave valor`, `--chave=valor` e flags booleanas. */
 function parseArgs(argv) {
     const posicionais = [];
@@ -77,44 +176,137 @@ function parseArgs(argv) {
 function texto(v) {
     return typeof v === 'string' ? v : undefined;
 }
+/**
+ * I-36 (D2, D6): o que o CLI declara sobre a conducao. `--canal` (sem ele, o que a borda exporta),
+ * `--correlacao` (conversa ou mensagem de origem) e `--esperar [minutos]` (sem valor, 30).
+ */
+function conducaoDoCli(args) {
+    if (args.opcoes.canal === true)
+        throw new Error('uso: --canal <claude-code|hermes|openclaw|codex|mcp|cli>');
+    const bruto = args.opcoes.esperar;
+    let esperarMs;
+    if (bruto === true)
+        esperarMs = conducao_1.ESPERA_PADRAO_MS;
+    else if (typeof bruto === 'string') {
+        const minutos = Number(bruto);
+        if (!Number.isFinite(minutos) || minutos <= 0 || minutos > 24 * 60)
+            throw new Error('uso: --esperar [minutos], de 1 a 1440 (sem valor, 30)');
+        esperarMs = Math.round(minutos * 60_000);
+    }
+    return { canal: (0, conducao_1.canalDoProcesso)(texto(args.opcoes.canal)), correlacao: texto(args.opcoes.correlacao) ?? null, esperarMs };
+}
 const AJUDA = `ork ${VERSAO}, nucleo de orquestracao do Orkastery
 
 Uso: ork <comando> [argumentos]
 
   doctor                                    O que vale nesta maquina agora (sai != 0 se bloqueado)
   init [--force] [--name N] [--abbrev A]    Gera o orkastery.yaml do repositorio
-  modos                                     Tabela dos 5 modos de conducao por #TAG
+  modos                                     Tabela dos ${modos_1.ORDEM_DOS_MODOS.length} modos de conducao vivos por #TAG
+
+  setup                                     Pauta da entrevista #setup: runtime/modelo/esforco
+  onboarding [show|set <etapa>|reset [etapa]] Pauta e respostas do projeto (9 etapas)
+        [--conteudo JSON] [--por Q] [--json]  Valores secretos somente em ~/.hermes/.env
+        [--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)
+  setup <modo>                              Config atual de cada bloco do modo
+  setup <modo> --bloco N [--runtime R]      Edita o bloco (runtimes: claude-bg, codex);
+        [--model M] [--effort E] [--por Q]       evento setup_configured no ledger do projeto
+        [--fallback R:M[:E],...]                  ordem de fallback de runtime do bloco (I-33)
+  accounts list [--json]                    Perfis de conta por runtime, sem segredo (I-33)
+  accounts add <id> --runtime R --dir D     Cria o perfil e roda o login do proprio CLI com o env
+        [--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
+  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)
 
   thread new <nome> --modo <MODO>           Cria a thread, o slug de 3 partes e o ledger
+        [--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]
-  thread list                               Threads do projeto
-  thread status <thread-id>                 Estado da thread, cruzado com o runtime
+        [--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
+  thread entrega <id> --arquivo A --sha256 H --por Q
+  thread status <thread-id> [--json]        Estado da thread, cruzado com o runtime
+
+  portfolio inspect <id> --json              Entidade, origem e ciclos com lacunas explícitas
+  creation start --input-file F --json       Criação durável com identidade do processo local
+  creation show|list|events [id] --json       Consulta journal e recuperação
+  creation resume|compensate <id> --expected-version N --json
+  portfolio create <product|project|initiative> <id> --title T [--parent ID]
+  portfolio list [product|project|initiative] [--parent ID] [--json]
+  portfolio show <id> [--json]              Catálogo prod -> proj -> init
+        [--constraints A;B] [--outcomes A;B] [--threads N]
+        [--execution-runtime R] [--validation-runtimes R1,R2]
+  objective ...                             Aposentado na I-43: as duas vigas viraram
+                                            --exige-runtime-diferente e --done de thread
 
   phase run <thread-id> <FASE> --prompt "<texto>"
-        [--model M] [--effort E] [--dry-run] Despacha a fase como background agent
-                                            (so --model assume --effort high; o par
+        [--runtime R] [--model M]           Despacha a fase como background agent
+        [--effort E] [--dry-run]                 (runtime: CLI > setup do bloco > manifesto;
+                                             so --model assume --effort high; o trio
                                              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)
   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))
+        [--thread T] [--modo M] [--runtime R] [--json]
+  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]                          Sessoes vivas do runtime, cruzadas com as threads
+  sessions [--all] [--global] [--json]      Inventário Claude e Codex da conta atual
+        [--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 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
+  sessions answer <thread> <pedido> --stdin --origem telegram --canal C --por ID --mensagem REF [--conta ID]  Confirma entrega autenticada
+  sessions reconcile <thread> <pedido>      Fecha envio pendente so com thread e pedido; consulta recibo, nunca reenvia
   sessions stop <sessao>                    Para uma sessao
   sessions attach <sessao>                  Imprime o comando de attach (precisa de TTY)
+  pulse [--json] [--registrar]             Fila unificada de atenção humana e retry de órfãs
+  pulse responder --resposta-stdin --origem telegram --canal C --por ID --mensagem REF [--conta ID]
+                                            Recebe o que o dono digitou no canal do resumo (P4EJ a, 1a 2c)
+  pulse cadencia [<tag>] [--por P] [--json] Mostra ou troca a cadencia do resumo: OrkPulseOn, OrkPulseOn-15m,
+                                            -30m, -60m ou OrkPulseOff; pergunta nova sai na hora (I-50)
+  sessions hitl [--json] [--so-paradas]     Radar de sessoes que exigem acao humana AGORA:
+        [--atencao N] [--sem-logs]              classifica o estado de cada sessao do runtime,
+        [--so-da-raiz] [--exigir-limpo]         le a pergunta que a sessao trava e diz o que
+                                                destrava (pega HITL de sessao SEM thread)
 
   claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"] [--fase F]
                                             Registra alegacao verificavel da thread
   claims list <thread-id>                   Claims da thread e o estado de cada uma
+  decisao registrar <thread-id> --decidido D --porque P --como-mudar C --custo-agora A --custo-depois B
+        --criterio manifesto:CHAVE|ledger:REF|medicao:COMANDO --quem Q --evidencia E [--razao R] [--reverte ID]
+                                            Decisao tomada sem perguntar: chega ao dono no resumo
+  decisao placar <thread-id> [--json]       Decididas contra perguntas por fase, reversoes e o limiar
   claims verificar <thread-id> <claim-id> --comando "<comando>"
                                             Anexa o comando que comprova uma claim ja feita
   claims retirar <thread-id> <claim-id> --motivo "<motivo>"
                                             Retira a alegacao (o historico fica no claims.jsonl)
+  claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]
+                                            Ciclo sem CHECK: declara no ledger o que ficou sem prova
   verify <thread-id> [--baseline]           Reexecuta claims e verify do manifesto no HEAD real
         [--so-claims]                       --baseline grava o estado do mundo antes do GO
+        [--canal C] [--esperar [min]]       So executa com a conducao da thread (sai 3 se outra conduz)
+  ci prepare <thread-id>                    Exporta claims/comandos para a candidata
+  ci run [<thread-id>] [--bundle ARQ]       Executa o CHECK no runner independente
+  ci status [--sha SHA] [--remoto origin]   Consulta o check exato publicado no GitHub
 
   gate next <thread-id> [--proximo FASE]    Gate de tokens: mesma sessao ou nova sessao
         [--ocupacao 0..1] [--fonte F] [--transcript ARQ] [--janela N] [--refazer]
-  gate approve <thread-id> <sobre> --por Q  Registra autorizacao humana no ledger
+  gate request <thread-id> [--motivo M]     Apresenta pedido HITL correlacionado à pausa
+  gate answer <thread-id> <pedido>          Recebe envelope do ingresso humano autenticado
+        --resposta-stdin --por Q --mensagem ID --origem telegram [--canal hermes|openclaw]
+        [--conta ID]  conta homologada do canal; obrigatoria no canal openclaw
+  gate approve                             Aposentado: aprovação sem pedido é recusada
 
   retry policy [--motivo M] [--json]        Politica de retry por motivo tipado de gate
   retry plan <thread-id> [--motivo M]       O que o ork faria pelo ultimo gate reprovado
@@ -141,15 +333,21 @@ Uso: ork <comando> [argumentos]
         [--id ptr-N] [--todos] [--forcar]        momento (retrieve_when), nunca a janela inteira
         [--sem-conteudo] [--json]                (orkmind por tag, files por path#ancora)
 
+  brain status|inventory|get|query|receipts|sync|reconcile|apply|rollback|bind
   memory status [--json]                    Regime efetivo (files|orkmind), tenant e degradacao
   memory sync [<thread-id>] [--json]        Publica decisoes, policies, handoff, licao e roadmap
+  memory inventory --escopo <threads> [--json]                 Inventaria fontes canonicas e tenants excluidos, sem gravar
+  memory migrate --operadora <thread> --escopo <threads> [--dry-run] [--json]                   Migra handoffs por G3, com pacote integral e readback
   memory search --tags '<json>' [--colecao C]  Busca deterministica por tag (mandatory sempre volta)
-        [--limite N] [--json]
+        [--thread ID] [--restrito] [--janela N] [--limite N] [--json]
 
   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
         [--de <branch>] [--remoto origin] [--autorizar-push <quem>] [--sem-push] [--dry-run]
 
-  board [--all]                             Visao unica das threads (todos os perfis com --all)
+  board [--all] [--sem-remoto]              Visao unica das threads (todos os perfis com --all); com a
+                                            fabrica compartilhada, tambem as outras maquinas (I-51)
   board plan                                Escalonador: quem avanca agora, quem espera e por que
 
   orquestracao status [--all] [--json]      Monitor PROATIVO de pausas e impedimentos: quem esta
@@ -161,18 +359,33 @@ Uso: ork <comando> [argumentos]
   worktree audit <thread-id>                Confere a worktree no proprio git (sai != 0 se divergir)
   worktree release <thread-id> [--forcar]   Remove a worktree e limpa o registro
 
+  activation plan|status|enable|disable     Escrita escopada com aceite, hash, leases e recibo
   lease list                                Leases, familias e as filas (merge e colisao de regiao)
   lease acquire <nome> --thread T --motivo M   Toma um lease tipado (entra na fila se colidir)
   lease release <nome> [--thread T] [--forcar]
+  conducao status <thread-id> [--json]      Quem conduz a thread agora (canal, sessao, fase, desde)
+  conducao assumir <thread-id> --por Q --motivo M
+                                            Handoff: encerra a conducao atual pelo runtime e registra quem assumiu
 
+  master propor <id> --score N --justificativa J --por <agente>
+  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]
                                             Fecha a thread: POSTMORTEM + MASTER log + score
-  master --batch [--todas]                  Fila de review em bloco (threads entregues sem score)
+  master [--todas] [--json]                 As entregas, com o indice derivado do ledger
+  master --aceitar-omissao [--json]         Aceita as entregues por omissao, com registro
   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)
 
+  demo [--manter] [--dir D]                 A promessa em 30 s: uma afirmacao falsa reprovada e a corrigida aceita,
+                                            offline, num repositorio temporario (I-56)
   ciclos                                    Variantes de ciclo de "ork thread new --ciclo"
   modos --do-pedido "<texto>" [--json]      Le a #TAG do pedido do builder (usado pelos adaptadores)
+  modos migrar [--dry-run] [--por Q]        Tira modo aposentado do orkastery.yaml e do setup.json
+        [--json]                             (idempotente, com backup; nao toca em historico)
 
   prompt list                               Templates de prompt (embutidos e os do projeto)
   prompt lint [--template ID]               Reprova template quebrado antes de ele virar despacho
@@ -180,10 +393,33 @@ Uso: ork <comando> [argumentos]
         [--pedido "<texto>"] [--template ID]
   prompt render --exemplo --fase F --modo M Renderiza sem thread nenhuma, para revisar o texto
 
+  roadmap reservas [--json] [--remoto R]    Quem esta com cada item do roadmap, lido da branch ork/roadmap-reservas
+  roadmap pegar <RM-NNN> [--thread T]       Reserva o item para esta maquina (push atomico: o primeiro vence)
+        [--nota N] [--por Q] [--maquina M]       maquina = --maquina, ORK_MAQUINA ou o hostname
+        [--forcar --motivo M]                    tomar a reserva de outra maquina fica registrado
+  roadmap soltar <RM-NNN> [--forcar --motivo M]  Devolve o item
+  fabrica [--json] [--sem-remoto]           O que cada maquina conduz, lido da branch ork/fabrica-estado (I-51)
+  fabrica entrar [--maquina NOME]           Esta maquina entra na fabrica compartilhada deste usuario, com
+                                            este nome (~/.orkastery/maquina.json), e publica o primeiro retrato
+  fabrica publicar [--forcar] [--json]      Grava o retrato desta maquina na branch (push atomico, sem forca);
+                                            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
+  docs verificar [--json]                   Documentacao de produto e roadmap contra o codigo e o git
+                                            (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
+  docs init                                 Cria padroes, modelos, indices e o lint de Markdown no projeto
+
+  mcp serve --project RAIZ --host HOST       Servidor MCP stdio deste projeto (codex|claude-code)
+  mcp install --project RAIZ --host HOST     Prepara MCP; aceita --dry-run, --ship-transport, --child-permissions e --owner-permissions (Codex)
+
   adapter list                              Adaptadores de host (Camada 1) e o destino de cada um
   adapter show <host>                       Os 3 pitfalls de instalacao do host
-  adapter install <host> [--dir D]          Instala o adaptador (hermes|openclaw|claude-code)
-        [--dry-run] [--force]
+  adapter install <host> [--dir D]          Instala o adaptador (claude-code|codex|hermes|openclaw)
+        [--dry-run] [--force]                    divergencia segura resolve sozinha; o resto pergunta
+        [--aceitar-catalogo <arquivo>]           sobrescreve a copia com o catalogo, arquivo a arquivo
+        [--manter-copia <arquivo>]               deixa a copia como esta, arquivo a arquivo
 
   eval [--skill S] [--canario C]            Canarios de comportamento + corpus das skills finas
         [--so-canarios] [--so-skills] [--json]   (sai != 0 em qualquer falha)
@@ -227,11 +463,11 @@ pausaSobre do bloco dizendo o que o humano decide); impedimento e a nao prevista
 DERIVADO de thread.json, ledger.jsonl e das filas em disco: o monitor le, nunca grava.
 --exigir-limpo sai != 0 enquanto houver thread parada, para virar watchdog do orquestrador.
 
-Fases: GOAL PLAN GO CHECK SHIP MASTER. Modos: #Look #Default #Ork #Maestro #Auto.
+Fases: GOAL PLAN GO CHECK SHIP MASTER. Modos: ${modos_1.ORDEM_DOS_MODOS.map((m) => modos_1.MODOS[m].tag).join(' ')}.
 Familias de lease: main-tree, worktree-write:<thread>, path:<glob>, board:<card>, service:<porta>.
 Ciclos: greenfield, merge-branch, goal-plan, gap, feature-xl-faseada.
 Fontes de medida do gate de tokens: runtime_reported, estimated, informada, unavailable.
-Hosts de Camada 1: claude-code, hermes, openclaw. Canarios: fx-happy, fx-hallucination,
+Hosts de Camada 1: claude-code, codex, hermes, openclaw. Canarios: fx-happy, fx-hallucination,
 fx-stale-base, fx-wiki-destroy, fx-schema-drift, fx-concurrency.
 Packs de auditoria: clean-code, reuse, architecture, data-model, ux, security-privacy, process.
 Superficie de ataque de rede (SP8..SP12, varredura deterministica): rota sem auth, endpoint de
@@ -239,6 +475,17 @@ administracao exposto, rota sem rate limit, CORS permissivo, rota sem esquema de
 Estagios do produto: nascente, crescendo, maduro (hardening gradual, visao secao 5.2).
 `;
 function comandoThread(args) {
+    if (args.posicionais[1] === 'close' || args.posicionais[1] === 'entrega') {
+        const raiz = (0, manifest_1.exigirManifesto)().raiz, id = args.posicionais[2];
+        if (!id)
+            throw new Error('informe o id da thread');
+        const por = texto(args.opcoes.por) ?? '';
+        const r = args.posicionais[1] === 'close'
+            ? (0, thread_close_1.fecharAdministrativamente)(raiz, id, { motivo: texto(args.opcoes.motivo) ?? '', por, justificativa: texto(args.opcoes.justificativa) ?? '' })
+            : (0, thread_close_1.registrarArtefato)(raiz, id, texto(args.opcoes.arquivo) ?? '', texto(args.opcoes.sha256) ?? '', por);
+        console.log(JSON.stringify(r, null, 2));
+        return 0;
+    }
     const sub = args.posicionais[1];
     if (sub === 'new') {
         const carregado = (0, manifest_1.exigirManifesto)();
@@ -247,10 +494,15 @@ function comandoThread(args) {
         const doAchado = texto(args.opcoes['from-finding']) ?? texto(args.opcoes['do-achado']);
         if (doAchado) {
             const brutoModoAchado = texto(args.opcoes.modo) ?? texto(args.opcoes.mode);
-            const modoAchado = brutoModoAchado ? (0, modos_1.parseModo)(brutoModoAchado) : undefined;
-            if (brutoModoAchado && !modoAchado) {
-                console.error(`modo invalido: "${brutoModoAchado}". Use um de: ${Object.values(modos_1.MODOS).map((m) => m.tag).join(', ')}`);
-                return 2;
+            let modoAchado;
+            if (brutoModoAchado !== undefined) {
+                try {
+                    modoAchado = (0, modos_1.exigirModoVivo)(brutoModoAchado);
+                }
+                catch (e) {
+                    console.error(e.message);
+                    return 2;
+                }
             }
             const brutoWorktreeAchado = args.opcoes.worktree;
             const criarWorktreeAchado = brutoWorktreeAchado === true || brutoWorktreeAchado === 'auto';
@@ -314,13 +566,35 @@ function comandoThread(args) {
             return 2;
         }
         const brutoModo = texto(args.opcoes.modo) ?? texto(args.opcoes.mode);
-        const modo = brutoModo
-            ? (0, modos_1.parseModo)(brutoModo)
-            : carregado.manifesto.conduction.default_mode;
-        if (!modo) {
-            console.error(`modo invalido: "${brutoModo}". Use um de: ${Object.values(modos_1.MODOS).map((m) => m.tag).join(', ')}`);
+        let modo;
+        try {
+            modo = brutoModo !== undefined
+                ? (0, modos_1.exigirModoVivo)(brutoModo)
+                : carregado.manifesto.conduction.default_mode;
+        }
+        catch (e) {
+            console.error(e.message);
             return 2;
         }
+        // I-43 (D4, viga a): a exigencia de validacao cruzada e declarada na criacao e
+        // fica gravada na thread, em vez de morar num envelope a parte.
+        const exigeRuntimeDiferente = args.opcoes['exige-runtime-diferente'] === true;
+        // I-43 (D4, viga b): `--done "criterio :: comando"`, com `;;` separando varios.
+        // O separador `::` e obrigatorio: criterio sem comando e a prosa que o envelope
+        // tinha, e o produto nao aceita de volta um criterio de pronto que ninguem executa.
+        const doneWhen = (texto(args.opcoes.done) ?? '').split(';;').map((p) => p.trim()).filter(Boolean)
+            .map((entrada) => {
+            const corte = entrada.indexOf('::');
+            if (corte < 0) {
+                throw new Error(`done.sem-comando: "${entrada}" nao traz comando. `
+                    + 'Use --done "<criterio> :: <comando que o prova>"; criterio sem comando e prosa, nao criterio de pronto.');
+            }
+            const criterio = entrada.slice(0, corte).trim();
+            const comando = entrada.slice(corte + 2).trim();
+            if (!criterio || !comando)
+                throw new Error(`done.incompleto: "${entrada}" precisa de criterio E comando`);
+            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;
@@ -333,19 +607,46 @@ function comandoThread(args) {
             return 2;
         }
         const brutoFatias = texto(args.opcoes.fatias);
-        const { thread, gravada } = (0, thread_1.novaThread)(carregado, {
-            nome,
-            modo,
-            slug: texto(args.opcoes.slug),
-            assunto: texto(args.opcoes.assunto),
-            worktree: criarWorktree ? null : (texto(brutoWorktree) ?? null),
-            criarWorktree,
-            dryRun,
-            variante,
-            branch: texto(args.opcoes.branch),
-            fatias: brutoFatias !== undefined ? Number(brutoFatias) : undefined,
-        });
+        // 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,
+        // a reserva e devolvida; se der certo, ela passa a apontar para a thread.
+        const itemDoRoadmap = dryRun ? undefined : texto(args.opcoes.roadmap);
+        const itemReservado = itemDoRoadmap ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap).item : undefined;
+        let criada;
+        try {
+            criada = (0, thread_1.novaThread)(carregado, {
+                nome,
+                modo,
+                slug: texto(args.opcoes.slug),
+                assunto: texto(args.opcoes.assunto),
+                worktree: criarWorktree ? null : (texto(brutoWorktree) ?? null),
+                criarWorktree,
+                dryRun,
+                variante,
+                branch: texto(args.opcoes.branch),
+                fatias: brutoFatias !== undefined ? Number(brutoFatias) : undefined,
+                exigeRuntimeDiferente,
+                doneWhen,
+                roadmap: itemReservado,
+            });
+        }
+        catch (e) {
+            if (itemDoRoadmap) {
+                try {
+                    (0, roadmap_reservas_1.soltarItem)(carregado.raiz, itemDoRoadmap);
+                }
+                catch { /* fica reservado; `ork roadmap soltar` resolve */ }
+            }
+            throw e;
+        }
+        const { thread, gravada } = criada;
+        const reservaDoItem = itemDoRoadmap && gravada ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, itemDoRoadmap, { thread: thread.id }) : null;
+        // I-51 (RM-047): com a fabrica compartilhada, as outras maquinas veem a thread nova.
+        if (gravada)
+            (0, fabrica_publicar_1.publicarEmSegundoPlano)(carregado.raiz);
         console.log(gravada ? 'Thread criada.' : 'Simulacao (--dry-run), nada foi gravado.');
+        if (reservaDoItem)
+            console.log(`  roadmap: ${reservaDoItem.item} reservado para esta maquina (${reservaDoItem.reserva?.maquina})`);
         console.log((0, thread_1.resumoDaThread)(thread));
         console.log('');
         console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(thread.slug)}`);
@@ -361,7 +662,16 @@ function comandoThread(args) {
     }
     if (sub === 'list' || sub === undefined) {
         const carregado = (0, manifest_1.exigirManifesto)();
-        console.log((0, thread_1.tabelaDeThreads)(carregado.raiz));
+        // I-43 (D8): `--todas` abre o que o default esconde, e `--json` passa a devolver
+        // JSON de verdade. Acrescentar uma flag numa tela onde `--json` era aceito e
+        // IGNORADO em silencio (saindo 0) seria deixar dois pesos na mesma linha.
+        const todas = args.opcoes.todas === true;
+        if (args.opcoes.json === true) {
+            const linhas = (0, thread_1.threadsDaListagem)(carregado.raiz, { todas });
+            console.log(JSON.stringify({ todas, total: linhas.length, threads: linhas }, null, 2));
+            return 0;
+        }
+        console.log((0, thread_1.tabelaDeThreads)(carregado.raiz, { todas }));
         return 0;
     }
     if (sub === 'status') {
@@ -372,8 +682,14 @@ function comandoThread(args) {
             return 2;
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        if (args.opcoes.json === true) {
+            // Idem: `ork thread status <id> --json` imprimia o TEXTO e saia 0.
+            console.log(JSON.stringify(thread, null, 2));
+            return 0;
+        }
         console.log(`Thread ${thread.id}`);
-        console.log((0, thread_1.resumoDaThread)(thread));
+        // I-36 (T17): a linha de conducao vem da leitura unica do nucleo.
+        console.log((0, thread_1.resumoDaThread)(thread, (0, conducao_1.conducaoDaThread)(carregado.raiz, thread.id)));
         console.log('');
         if (thread.sessoes.length === 0) {
             console.log('  nenhuma sessao despachada ainda');
@@ -382,7 +698,7 @@ function comandoThread(args) {
             console.log('  sessoes despachadas (estado real conferido em `ork sessions`)');
             for (const s of thread.sessoes) {
                 console.log(`    ${s.slug.padEnd(24)} ${s.fase.padEnd(6)} ${s.sessionId.slice(0, 8)}  ` +
-                    `verificada no runtime: ${s.verificada ? 'sim' : 'nao'}`);
+                    `verificada no runtime: ${s.verificada ? 'sim' : 'nao'}  canal: ${(0, thread_1.canalDaSessao)(s)}`);
             }
         }
         console.log('');
@@ -392,10 +708,280 @@ function comandoThread(args) {
     console.error(`subcomando desconhecido: thread ${sub}`);
     return 2;
 }
+/**
+ * `ork setup [modo]`: a feature #setup no nucleo.
+ *
+ * Sem argumento, imprime a pauta da entrevista (a lista topificada dos modos vivos com a
+ * config atual de cada bloco): e o texto que o orquestrador entrega ao owner quando a
+ * tag #setup chega no pedido. Com um modo, mostra/edita/reseta a config daquele modo.
+ * Toda edicao vira evento `setup_configured` no ledger do projeto.
+ */
+function comandoOnboarding(args) {
+    const invalido = () => { throw new Error('onboarding.input.invalid: use ork onboarding [show|set <etapa>|reset [etapa]] --conteudo <JSON> [--por Q] [--json]'); };
+    if (Object.keys(args.opcoes).some(k => !['conteudo', 'por', 'json', 'reset'].includes(k)))
+        invalido();
+    if ('json' in args.opcoes && args.opcoes.json !== true)
+        invalido();
+    if ('por' in args.opcoes && typeof args.opcoes.por !== 'string')
+        invalido();
+    const alias = 'reset' in args.opcoes;
+    const sub = alias ? 'reset' : args.posicionais[1] ?? 'show';
+    const etapa = alias ? texto(args.opcoes.reset) : args.posicionais[2];
+    if (alias && args.posicionais.length !== 1)
+        invalido();
+    if (!['show', 'set', 'reset', 'sync'].includes(sub))
+        invalido();
+    if (['show', 'sync'].includes(sub) && (args.posicionais.length > 2 || 'conteudo' in args.opcoes))
+        invalido();
+    if (sub === 'set' && (!etapa || args.posicionais.length !== 3 || typeof args.opcoes.conteudo !== 'string'))
+        invalido();
+    if (sub === 'reset' && (args.posicionais.length > 3 || 'conteudo' in args.opcoes))
+        invalido();
+    if (sub === 'sync' && 'por' in args.opcoes)
+        throw new Error('onboarding.input.invalid: sync não aceita --por; informe autoria em set ou reset.');
+    const carregado = (0, manifest_1.exigirManifesto)(), raiz = carregado.raiz, por = texto(args.opcoes.por) ?? 'owner';
+    if (sub === 'sync') {
+        const r = (0, memoria_1.sincronizarOnboarding)(carregado);
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : `${r.regime}${r.motivo ? ` (${r.motivo})` : ''}: ${r.detalhe}`);
+        return 0;
+    }
+    let estado;
+    if (sub === 'set') {
+        let conteudo;
+        try {
+            conteudo = JSON.parse(args.opcoes.conteudo);
+        }
+        catch {
+            return invalido();
+        }
+        estado = (0, onboarding_1.gravarEtapa)(raiz, etapa, conteudo, por);
+    }
+    else if (sub === 'reset')
+        estado = (0, onboarding_1.resetarOnboarding)(raiz, etapa, por);
+    else
+        estado = (0, onboarding_1.lerOnboarding)(raiz);
+    console.log(args.opcoes.json === true ? JSON.stringify(estado, null, 2) : (0, onboarding_1.textoDaPauta)(estado));
+    return 0;
+}
+/**
+ * I-33 (D8): `ork accounts list|add|remove|check`. O login e sempre do proprio CLI com o env do
+ * perfil (`claude auth login`, `codex login`); o `ork` so guarda identidade, diretorio e estado,
+ * nunca le, copia ou migra o que o CLI grava. A lista nao tem segredo porque o store nao tem.
+ */
+/** A8: valor citado para colar no shell: aspas simples, e a aspa simples do proprio valor fechada e reaberta. */
+function aspasDeShell(valor) {
+    return `'${valor.split("'").join(`'"'"'`)}'`;
+}
+/**
+ * I-33 (N2): o aviso da chave de troca entre perfis sai no proprio comando que a usa (`phase run`,
+ * `retry`, `accounts`), nao so no `ork doctor`: valor invalido nunca liga a troca em silencio.
+ */
+function avisarChavesDePerfis(carregado) {
+    for (const a of carregado.avisos)
+        if (a.startsWith('runtime_profiles.'))
+            console.error(`aviso: ${a}`);
+}
+function comandoAccounts(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    avisarChavesDePerfis(carregado);
+    const raiz = carregado.raiz;
+    const sub = args.posicionais[1] ?? 'list';
+    const conferir = (p) => p.runtime === 'claude-bg' ? (0, claude_bg_1.conferirAuth)(p) : (0, codex_1.conferirAuth)(p);
+    const imprimir = () => {
+        const store = (0, runtime_profiles_1.lerPerfis)(raiz);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(store, null, 2));
+            return;
+        }
+        // I-49: a tabela mostra o que o despacho enxerga, com o que outra fabrica viu na mesma conta.
+        const visto = (0, runtime_profiles_1.lerPerfisComContas)(raiz);
+        console.log(visto.perfis.length === 0 ? 'Nenhum perfil configurado: cada runtime despacha pelo ambiente do processo.'
+            : (0, util_1.tabela)(runtime_profiles_1.COLUNAS_DE_PERFIS, (0, runtime_profiles_1.linhasDePerfis)(visto)));
+        // I-35: a tabela mostra horario do dono; o fuso sai uma vez, no fim da mensagem.
+        if ((0, runtime_profiles_1.perfisComHorario)(store))
+            console.log((0, horario_1.legendaDoFuso)());
+    };
+    if (sub === 'list') {
+        imprimir();
+        return 0;
+    }
+    if (sub === 'add') {
+        const id = args.posicionais[2], runtime = texto(args.opcoes.runtime), dirBruto = texto(args.opcoes.dir);
+        if (!id || !runtime || !dirBruto) {
+            console.error('uso: ork accounts add <id> --runtime claude-bg|codex --dir <diretorio> [--sem-login]');
+            return 2;
+        }
+        const dir = path.resolve(dirBruto);
+        let perfil;
+        try {
+            // A7: diretorio inacessivel ou de outro usuario e recusado antes de qualquer gravacao no store.
+            (0, runtime_profiles_1.prepararDiretorioDoPerfil)(dir);
+            const desativado = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.some(p => p.id === id && p.estado === 'desativado');
+            perfil = (0, runtime_profiles_1.adicionarPerfil)(raiz, { id, runtime, dir });
+            if (desativado)
+                console.log(`Perfil ${id} reativado: mesmo id, runtime e diretorio do perfil desativado.`);
+        }
+        catch (e) {
+            console.error(`perfil recusado: ${e.message}`);
+            return 1;
+        }
+        const despacho = (0, runtime_profiles_1.perfilDeDespacho)(perfil);
+        const variavel = runtime_profiles_1.VARIAVEL_DO_PERFIL[perfil.runtime];
+        // D13: o login do claude e fixado na assinatura (`--claudeai`), nunca no Console de API.
+        const comando = perfil.runtime === 'claude-bg' ? ['claude', 'auth', 'login', '--claudeai'] : ['codex', 'login'];
+        if (args.opcoes['sem-login'] !== true && process.stdin.isTTY && process.stdout.isTTY) {
+            // Login interativo do proprio CLI, com o env do perfil sobre a assinatura higienizada.
+            const env = perfil.runtime === 'claude-bg' ? (0, claude_bg_1.ambienteDoPerfil)(despacho) : (0, codex_1.ambienteDoDespacho)(process.env, despacho);
+            (0, node_child_process_1.spawnSync)(comando[0], comando.slice(1), { stdio: 'inherit', env });
+        }
+        else {
+            console.log(`Login pendente: rode ${variavel}=${aspasDeShell(dir)} ${comando.join(' ')} e depois ork accounts check ${id}`);
+        }
+        const auth = conferir(despacho);
+        // A14: conferencia inconclusiva nao marca sem-auth; o preflight do proximo despacho confere de novo.
+        if (!auth.ok && !auth.transitorio)
+            (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, id, auth.pago
+                ? { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe }
+                : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe });
+        console.log(`Perfil ${id} (${perfil.runtime}) em ${dir}: ${auth.ok ? 'login de assinatura conferido'
+            : auth.transitorio ? `conferencia de login inconclusiva (${auth.detalhe}); o proximo despacho confere de novo`
+                : auth.pago ? `provider pago (${auth.detalhe}); nunca recebe despacho` : `sem login (${auth.detalhe}); fora do rodizio`}`);
+        return 0;
+    }
+    if (sub === 'remove') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork accounts remove <id>');
+            return 2;
+        }
+        try {
+            (0, runtime_profiles_1.desativarPerfil)(raiz, id);
+        }
+        catch (e) {
+            console.error(e.message);
+            return 1;
+        }
+        console.log(`Perfil ${id} desativado: o diretorio e o login do CLI ficam onde estao.`);
+        return 0;
+    }
+    if (sub === 'check') {
+        const alvo = args.posicionais[2];
+        const perfis = (0, runtime_profiles_1.lerPerfis)(raiz).perfis.filter(p => p.estado !== 'desativado' && (alvo === undefined || p.id === alvo));
+        if (alvo !== undefined && perfis.length === 0) {
+            console.error(`perfil ativo "${alvo}" nao existe (veja: ork accounts list)`);
+            return 1;
+        }
+        let falhas = 0;
+        for (const p of perfis) {
+            const auth = conferir((0, runtime_profiles_1.perfilDeDespacho)(p));
+            if (auth.ok && (p.estado === 'sem-auth' || p.estado === 'provider-pago'))
+                (0, runtime_profiles_1.reativarPerfil)(raiz, p.id);
+            if (!auth.ok)
+                falhas++;
+            if (!auth.ok && auth.transitorio)
+                (0, runtime_profiles_1.registrarConferenciaInconclusiva)(raiz, p.id, auth.detalhe);
+            else if (!auth.ok) {
+                (0, runtime_profiles_1.marcarFalhaDePerfil)(raiz, p.id, auth.pago
+                    ? { estado: 'provider-pago', esgotadoAte: null, motivo: 'cost.violation', detalhe: auth.detalhe }
+                    : { estado: 'sem-auth', esgotadoAte: null, motivo: 'runtime.auth-missing', detalhe: auth.detalhe });
+            }
+            console.log(`${p.id} (${p.runtime}): ${auth.ok ? 'login de assinatura conferido'
+                : auth.transitorio ? `conferencia de login inconclusiva, estado mantido (${auth.detalhe})`
+                    : auth.pago ? `provider pago, nunca despacha (${auth.detalhe})` : `sem login (${auth.detalhe})`}`);
+        }
+        console.log('');
+        imprimir();
+        return falhas > 0 ? 1 : 0;
+    }
+    console.error(`subcomando desconhecido: accounts ${sub} (use list, add, remove ou check)`);
+    return 2;
+}
+function comandoSetup(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const raiz = carregado.raiz;
+    const modoBruto = args.posicionais[1];
+    const por = texto(args.opcoes.por) ?? 'owner';
+    if (modoBruto === 'versionar') {
+        // I-52 (RM-047): o setup que vale agora vai para orkastery.setup.json, para entrar por PR.
+        const r = (0, setup_1.versionarSetup)(raiz, por);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify({ caminho: r.caminho, setup: r.setup }, null, 2));
+            return 0;
+        }
+        console.log(`Setup versionado em ${r.caminho}.`);
+        console.log('  Leve para o repositorio por PR: dali em diante ele vale em todas as maquinas, e ork setup <modo> --bloco N passa a editar este arquivo.');
+        return 0;
+    }
+    if (!modoBruto) {
+        if (args.opcoes.reset === true) {
+            (0, setup_1.resetarSetup)(raiz, undefined, por);
+            if (args.opcoes.json === true) {
+                console.log(JSON.stringify((0, setup_1.lerSetup)(raiz), null, 2));
+                return 0;
+            }
+            console.log('Setup resetado: todos os blocos de todos os modos voltaram ao default.');
+            console.log((0, setup_1.textoDaEntrevista)(raiz));
+            return 0;
+        }
+        console.log(args.opcoes.json === true ? JSON.stringify((0, setup_1.lerSetup)(raiz), null, 2) : (0, setup_1.textoDaEntrevista)(raiz));
+        return 0;
+    }
+    const modo = (0, modos_1.parseModo)(modoBruto);
+    if (!modo) {
+        console.error(`modo de conducao desconhecido: "${modoBruto}" (aceitos: ${modos_1.ORDEM_DOS_MODOS.join(', ')})`);
+        return 2;
+    }
+    if (args.opcoes.reset === true) {
+        (0, setup_1.resetarSetup)(raiz, modo, por);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify((0, setup_1.lerSetup)(raiz).modos[modo], null, 2));
+            return 0;
+        }
+        console.log(`Setup do modo ${modos_1.MODOS[modo].tag} resetado para o default.`);
+        console.log('');
+        console.log((0, setup_1.textoDoSetup)(raiz, modo));
+        return 0;
+    }
+    const bloco = texto(args.opcoes.bloco);
+    const runtime = texto(args.opcoes.runtime);
+    const model = texto(args.opcoes.model);
+    const effort = texto(args.opcoes.effort);
+    // I-33 (D6): `--fallback runtime:modelo[:esforco],...`; `--fallback ""` remove a ordem.
+    const fallbackBruto = args.opcoes.fallback === true ? '' : texto(args.opcoes.fallback);
+    const fallback = fallbackBruto === undefined ? undefined : fallbackBruto.split(',').map(s => s.trim()).filter(s => s !== '');
+    if (bloco === undefined && (runtime !== undefined || model !== undefined || effort !== undefined || fallback !== undefined)) {
+        console.error('para editar, informe o bloco: ork setup <modo> --bloco N [--runtime R] [--model M] [--effort E] [--fallback R:M,...]');
+        return 2;
+    }
+    if (bloco !== undefined) {
+        if (runtime === undefined && model === undefined && effort === undefined && fallback === undefined) {
+            console.error('nada para editar: informe --runtime, --model, --effort e/ou --fallback junto de --bloco');
+            return 2;
+        }
+        const r = (0, setup_1.editarBloco)(raiz, modo, Number(bloco), { runtime, model, effort, ...(fallback !== undefined ? { fallback } : {}) }, por);
+        if (!r.ok) {
+            console.error(`edicao recusada: ${r.erro}`);
+            return 1;
+        }
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(r.setup.modos[modo], null, 2));
+            return 0;
+        }
+        console.log(`Bloco ${r.bloco} do modo ${modos_1.MODOS[modo].tag}: ` +
+            `${r.de?.runtime}/${r.de?.model}/${r.de?.effort} -> ${r.para?.runtime}/${r.para?.model}/${r.para?.effort}`);
+        console.log(`  gravado em ${r.caminho}; evento setup_configured no ledger do projeto`);
+        console.log('');
+        console.log((0, setup_1.textoDoSetup)(raiz, modo));
+        return 0;
+    }
+    console.log(args.opcoes.json === true ? JSON.stringify((0, setup_1.lerSetup)(raiz).modos[modo], null, 2) : (0, setup_1.textoDoSetup)(raiz, modo));
+    return 0;
+}
 function comandoPhase(args) {
     const sub = args.posicionais[1];
     const carregado = (0, manifest_1.exigirManifesto)();
     if (sub === 'run') {
+        avisarChavesDePerfis(carregado);
         const id = args.posicionais[2];
         const faseBruta = args.posicionais[3];
         const prompt = texto(args.opcoes.prompt);
@@ -405,21 +991,39 @@ function comandoPhase(args) {
         }
         const thread = (0, thread_1.lerThread)(carregado.raiz, id);
         const fase = (0, thread_1.exigirFase)(thread, faseBruta);
+        const conducao = conducaoDoCli(args);
         const r = (0, phase_1.rodarFase)(carregado, id, {
             fase,
             prompt,
+            runtime: texto(args.opcoes.runtime),
             model: texto(args.opcoes.model),
             effort: texto(args.opcoes.effort),
             dryRun: args.opcoes['dry-run'] === true,
+            canal: conducao.canal,
+            ...(conducao.correlacao ? { correlacao: conducao.correlacao } : {}),
+            ...(conducao.esperarMs ? { esperarMs: conducao.esperarMs } : {}),
         });
-        if (r.dryRun) {
+        // I-36 (T12, T14): pedido repetido e segundo pedido tem resposta propria, antes dos outros gates.
+        if (r.idempotente && r.conducao) {
+            console.log((0, conducao_1.textoDoPedidoRepetido)(id, r.conducao));
+            return 0;
+        }
+        if (r.motivo === 'conducao.em-andamento') {
+            console.log(args.opcoes.json === true && r.recusa ? JSON.stringify(r.recusa, null, 2) : r.recusa?.texto ?? r.erro);
+            return 3;
+        }
+        if (r.dryRun && !r.bloqueado) {
             console.log('Simulacao (--dry-run), nada foi despachado.');
             console.log(`  slug da sessao : ${r.slug}`);
             console.log(`  prompt         : ${r.promptPath}`);
             console.log(`  sha256         : ${r.promptSha256}`);
             console.log(`  pausa ao fim   : ${r.pausaAoFim ? 'sim' : 'nao'}`);
+            console.log(`  runtime        : ${r.runtime}`);
             console.log(`  modelo/esforco : ${r.model}/${r.effort}`);
-            console.log(`  comando        : claude --bg "<prompt>" --name ${r.slug} ...`);
+            // O prompt inteiro nao cabe na tela: o argumento longo aparece mascarado.
+            console.log(`  comando        : ${r.comando.map((c) => (c.length > 80 ? '"<prompt>"' : c)).join(' ')}`);
+            for (const l of (0, policies_1.linhasDeAviso)(r.violacoes ?? []))
+                console.log(l);
             return 0;
         }
         if (r.bloqueado) {
@@ -432,20 +1036,29 @@ function comandoPhase(args) {
             return 1;
         }
         if (!r.sessionId) {
-            console.error(`Despacho falhou: ${r.erro}`);
+            // I-35: o erro vai ao ledger com o ISO; o dono le no fuso dele, com o fuso dito uma vez.
+            console.error(`Despacho falhou: ${r.erro ? (0, horario_1.localizarTextoRotulado)(r.erro) : r.erro}`);
             console.error(`  evento registrado no ledger de ${id}`);
             return 1;
         }
         console.log(`Fase ${fase} despachada como background agent.`);
+        for (const l of (0, policies_1.linhasDeAviso)(r.violacoes ?? []))
+            console.log(l);
         console.log(`  sessionId      : ${r.sessionId}`);
         console.log(`  slug da sessao : ${r.slug} (${(0, phase_1.descreverSlug)(r.slug)})`);
         console.log(`  prompt         : ${r.promptPath}`);
         console.log(`  sha256         : ${r.promptSha256}`);
+        console.log(`  runtime        : ${r.runtime}`);
         console.log(`  modelo/esforco : ${r.model}/${r.effort} (gravado no ledger, veja \`ork phase list\`)`);
         console.log(`  verificada no runtime: ${r.verificada ? 'sim' : 'NAO (confira `ork sessions`)'}`);
         console.log(`  pausa ao fim do bloco: ${r.pausaAoFim ? 'sim' : 'nao (decisao autonoma no ledger)'}`);
         console.log('');
-        console.log(`Acompanhe: claude attach ${r.sessionId}  |  ork phase list ${id}`);
+        if (r.runtime === 'claude-bg') {
+            console.log(`Acompanhe: claude attach ${r.sessionId}  |  ork phase list ${id}`);
+        }
+        else {
+            console.log(`Acompanhe: ork phase list ${id} (eventos do despacho no log da thread)`);
+        }
         return r.verificada ? 0 : 1;
     }
     if (sub === 'list') {
@@ -460,12 +1073,137 @@ function comandoPhase(args) {
     console.error(`subcomando desconhecido: phase ${sub}`);
     return 2;
 }
+function comandoLedger(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    if (sub === 'stats') {
+        const desde = texto(args.opcoes.desde);
+        if (!desde)
+            throw Error('uso: ork ledger stats --desde 7d [--ate ISO] [--thread T] [--modo M] [--runtime R] [--json]');
+        const r = (0, ledger_stats_1.coletarEstatisticas)(carregado.raiz, { desde, ate: texto(args.opcoes.ate), thread: texto(args.opcoes.thread), modo: texto(args.opcoes.modo), runtime: texto(args.opcoes.runtime) });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, ledger_stats_1.textoDasEstatisticas)(r));
+        return 0;
+    }
+    if (sub === 'estimate') {
+        const thread = args.posicionais[2], semIa = Number(texto(args.opcoes['sem-ia'])), iaSemOrk = Number(texto(args.opcoes['ia-sem-ork']));
+        const por = texto(args.opcoes.por), metodo = texto(args.opcoes.metodo), premissas = texto(args.opcoes.premissas);
+        if (!thread || !por || !metodo || !premissas)
+            throw Error('uso: ork ledger estimate <thread-id> --sem-ia H --ia-sem-ork H --por Q --metodo M --premissas P [--incerteza I]');
+        const e = (0, ledger_stats_1.registrarEstimativaPlano)(carregado.raiz, thread, { semIaHoras: semIa, iaSemOrkHoras: iaSemOrk, por, metodo, premissas, incerteza: texto(args.opcoes.incerteza) });
+        console.log(args.opcoes.json === true ? JSON.stringify(e, null, 2) : `Estimativa PLAN registrada em ${thread}: sem IA ${semIa} h; IA sem Orkastery ${iaSemOrk} h.`);
+        return 0;
+    }
+    throw Error('uso: ork ledger stats|estimate ...');
+}
+/**
+ * `ork sessions hitl`: quem, entre as sessoes do runtime, espera o humano AGORA.
+ *
+ * Complementa o `ork monitor`, que e thread-centrico: aqui a varredura parte das SESSOES,
+ * entao ela enxerga a sessao `claude --bg` que travou em HITL sem ter thread nenhuma --
+ * o buraco exato do incidente de 05/09/2026 (codigo 2FA do `npm publish`).
+ *
+ * O `--exigir-limpo` transforma o radar em watchdog: sai != 0 enquanto houver sessao
+ * esperando humano, entao um cron ou o proprio orquestrador trata "tem gente esperando"
+ * como falha acionavel, sem precisar interpretar texto.
+ */
+function comandoSessionsHitl(args, raiz) {
+    const bruto = texto(args.opcoes.atencao);
+    const atencaoMin = bruto === undefined ? undefined : Number(bruto);
+    if (atencaoMin !== undefined && (!Number.isFinite(atencaoMin) || atencaoMin < 0)) {
+        console.error(`--atencao espera minutos (inteiro >= 0), recebeu "${bruto}"`);
+        return 2;
+    }
+    const radar = (0, hitl_1.varrerSessoes)({
+        raiz,
+        registrar: args.opcoes.registrar === true,
+        escopo: texto(args.opcoes.escopo)?.split(',').map(s => s.trim()),
+        registrarMaquina: args.opcoes['registrar-maquina'] === true,
+        linhasLogs: texto(args.opcoes.linhas) === undefined ? undefined : Number(texto(args.opcoes.linhas)),
+        soDaRaiz: args.opcoes['so-da-raiz'] === true,
+        soParadas: args.opcoes['so-paradas'] === true,
+        semLogs: args.opcoes['sem-logs'] === true,
+        atencaoMin,
+    });
+    console.log(args.opcoes.json === true ? JSON.stringify(radar, null, 2) : (0, hitl_1.textoDoRadar)(radar));
+    if (!radar.runtimeConsultado)
+        return 1;
+    if (args.opcoes['exigir-limpo'] === true)
+        return radar.resumo.precisamDeHumano > 0 ? 1 : 0;
+    return 0;
+}
 function comandoSessions(args) {
     const sub = args.posicionais[1];
     const carregado = (0, manifest_1.carregarManifesto)();
     const raiz = carregado?.raiz ?? process.cwd();
+    if (sub === 'watch') {
+        const id = texto(args.opcoes.thread);
+        if (!carregado || !id) {
+            console.error('uso: ork sessions watch --thread T [--sessao ID] [--once]');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(raiz, id);
+        const sessionId = texto(args.opcoes.sessao) ?? thread.sessoes.at(-1)?.sessionId;
+        if (!sessionId || !thread.sessoes.some(s => s.sessionId === sessionId))
+            throw new Error('sessão não pertence à thread');
+        console.log(JSON.stringify(args.opcoes.once === true ? (0, session_watcher_1.observarSessao)(carregado, sessionId) : { pid: (0, session_watcher_1.iniciarWatcher)(raiz, sessionId) }));
+        return 0;
+    }
+    if (sub === 'event') {
+        const tipo = texto(args.opcoes.tipo), sessao = texto(args.opcoes.sessao);
+        if (!carregado || !tipo || !sessao) {
+            console.error('uso: ork sessions event --tipo <tipo> --sessao <id> < payload.json (máximo 16384 bytes)');
+            return 2;
+        }
+        try {
+            console.log(JSON.stringify((0, session_events_1.ingerirEvento)(raiz, sessao, tipo, (0, session_events_1.lerPayloadSensor)())));
+            return 0;
+        }
+        catch (e) {
+            console.error(`evento recusado: ${e.message}`);
+            return 1;
+        }
+    }
     if (sub === undefined || sub === 'list') {
-        console.log((0, sessoes_1.tabelaDeSessoes)(raiz, args.opcoes.all === true));
+        const r = (0, sessoes_inventario_1.inventariarSessoes)(raiz, { todas: args.opcoes.all === true, global: args.opcoes.global === true });
+        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 === 'hitl') {
+        return comandoSessionsHitl(args, carregado ? raiz : '');
+    }
+    if (sub === 'request') {
+        const id = args.posicionais[2], sessionId = args.posicionais[3];
+        const fase = texto(args.opcoes.fase), runtime = texto(args.opcoes.runtime), pergunta = texto(args.opcoes.pergunta);
+        if (!id || !sessionId || !fase || !types_1.FASES.includes(fase) || !runtime)
+            throw new Error('sessions request exige thread, UUID, --fase e --runtime; --pergunta só confere o conteúdo nativo');
+        console.log(JSON.stringify((0, hitl_sessions_1.abrirPedidoSessao)(raiz, id, sessionId, { fase: fase, runtime, pergunta, prazo: texto(args.opcoes.prazo) })));
+        return 0;
+    }
+    if (sub === 'answer') {
+        const id = args.posicionais[2], pedido = args.posicionais[3];
+        if (!id || !pedido || args.opcoes.stdin !== true)
+            throw new Error('sessions answer exige thread, pedido e envelope autenticado em --stdin');
+        const r = (0, hitl_gates_1.lerRespostaStdin)({ origem: texto(args.opcoes.origem), por: texto(args.opcoes.por),
+            mensagem: texto(args.opcoes.mensagem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
+        console.log(JSON.stringify((0, hitl_sessions_1.responderSessao)(raiz, id, pedido, r)));
+        return 0;
+    }
+    if (sub === 'reconcile') {
+        // FX3: fecha um envio pendente so com (thread, pedido). Nao reenvia e nao re-elicita:
+        // pergunta ao receptor, pelo recibo correlacionado, se ele recebeu aquele envioId.
+        const id = args.posicionais[2], pedido = args.posicionais[3];
+        if (!id || !pedido)
+            throw new Error('sessions reconcile exige thread e pedido');
+        const r = (0, hitl_sessions_1.reconciliarEnvioDeSessao)(raiz, id, pedido);
+        console.log(JSON.stringify(r));
+        return r.estado === 'entregue' ? 0 : 1;
+    }
+    if (sub === 'supersede') {
+        const id = args.posicionais[2], sessionId = args.posicionais[3];
+        const fase = texto(args.opcoes.fase), runtime = texto(args.opcoes.runtime);
+        if (!id || !sessionId || !fase || !types_1.FASES.includes(fase) || !runtime)
+            throw new Error('sessions supersede exige thread, UUID, --fase e --runtime');
+        console.log(JSON.stringify((0, hitl_sessions_1.superarSessao)(raiz, id, sessionId, fase, runtime)));
         return 0;
     }
     const chave = args.posicionais[2];
@@ -473,25 +1211,110 @@ function comandoSessions(args) {
         console.error(`uso: ork sessions ${sub} <sessao>`);
         return 2;
     }
+    if (sub === 'adopt') {
+        const r = (0, sessoes_adopt_1.adotarSessao)((0, manifest_1.exigirManifesto)(), chave);
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) :
+            `${r.detalhe}${r.vinculo ? `: ${r.sessionId} -> ${r.vinculo.thread} (${r.vinculo.raiz})` : ''}`);
+        return r.ok ? 0 : 1;
+    }
     if (sub === 'logs') {
         const n = Number(texto(args.opcoes.linhas) ?? '60');
-        const r = (0, sessoes_1.logsDaSessao)(chave, Number.isFinite(n) ? n : 60);
+        const r = (0, sessoes_2.logsDaSessao)(chave, Number.isFinite(n) ? n : 60);
         console.log(r.texto);
         return r.codigo;
     }
     if (sub === 'stop') {
-        const r = (0, sessoes_1.pararSessao)(chave);
+        const r = (0, sessoes_2.pararSessao)(chave);
         console.log(r.texto);
         return r.codigo;
     }
     if (sub === 'attach') {
-        const r = (0, sessoes_1.comandoDeAttach)(chave);
+        const r = (0, sessoes_2.comandoDeAttach)(chave);
         console.log(r.texto);
         return r.codigo;
     }
     console.error(`subcomando desconhecido: sessions ${sub}`);
     return 2;
 }
+/**
+ * I-41 (GO-FIX 1, B4): a decisao que a sessao toma sem perguntar ao dono vai ao ledger por aqui,
+ * com o que foi decidido, o porque, como mudar, o custo de reverter, o criterio escrito, quem
+ * decidiu e a evidencia. E assim que ela chega ao dono no resumo, em vez de sumir na conversa.
+ */
+function comandoDecisao(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1], id = args.posicionais[2];
+    if (sub === 'registrar') {
+        const campo = (nome) => {
+            const v = texto(args.opcoes[nome]);
+            if (!v)
+                throw new Error(`decisao registrar exige --${nome}`);
+            return v;
+        };
+        if (!id)
+            throw new Error('uso: ork decisao registrar <thread-id> --decidido D --porque P ...');
+        const bruto = campo('criterio'), separador = bruto.indexOf(':');
+        const tipo = bruto.slice(0, separador), referencia = bruto.slice(separador + 1);
+        if (separador < 1 || !['manifesto', 'ledger', 'medicao'].includes(tipo) || !referencia.trim()) {
+            throw new Error('decisao registrar: --criterio manifesto:CHAVE, ledger:REF ou medicao:COMANDO');
+        }
+        const { pedido, evento } = (0, decisao_autonoma_1.registrarDecisao)(carregado.raiz, id, {
+            decidido: campo('decidido'), porque: campo('porque'), comoMudar: campo('como-mudar'),
+            custoDeReverter: { agora: campo('custo-agora'), depois: campo('custo-depois') },
+            criterio: { tipo, referencia }, quemDecidiu: campo('quem'), evidencia: campo('evidencia'),
+            razao: texto(args.opcoes.razao), reverte: texto(args.opcoes.reverte),
+        });
+        const placar = (0, decisao_autonoma_1.placarDaThread)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, id))).find(f => f.fase === pedido.fase);
+        console.log(JSON.stringify({ ok: true, pedidoId: pedido.id, eventId: evento.eventId, fase: pedido.fase, placar }));
+        return 0;
+    }
+    if (sub === 'placar') {
+        if (!id)
+            throw new Error('uso: ork decisao placar <thread-id> [--json]');
+        (0, thread_1.lerThread)(carregado.raiz, id);
+        const placar = (0, decisao_autonoma_1.placarDaThread)((0, ledger_1.lerLedger)((0, thread_1.dirThread)(carregado.raiz, id)));
+        const taxa = (0, decisao_autonoma_1.taxaDeReversao)(placar);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify({ thread: id, limiar: decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE, taxaDeReversao: taxa, fases: placar }, null, 2));
+            return 0;
+        }
+        console.log((0, util_1.tabela)(['FASE', 'DECIDIDAS', 'INFORMADAS', 'PERGUNTAS', 'REVERTIDAS', 'SEM RASTRO', 'LIMIAR'], placar.map(f => [f.fase, String(f.decididas), String(f.informadas), String(f.perguntas), String(f.revertidas),
+            String(f.semRastro), f.acimaDoLimiar ? `acima de ${decisao_autonoma_1.LIMIAR_DE_DECISOES_POR_FASE}: revisar` : 'ok'])));
+        console.log(`\ntaxa de reversão das decisões informadas: ${taxa === null ? 'sem decisão informada ainda' : `${Math.round(taxa * 100)}%`}`);
+        return 0;
+    }
+    throw new Error('uso: ork decisao registrar|placar <thread-id>');
+}
+/**
+ * I-50 (RM-039): a tag que o dono manda no Telegram, pelo terminal. Sem tag, mostra a cadencia em
+ * vigor. O `#` e opcional porque o shell trata `#` no inicio da palavra como comentario.
+ */
+function comandoCadenciaDoPulse(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    if (args.posicionais.length > 3)
+        throw new Error('pulse cadencia: uma tag por vez');
+    const bruta = args.posicionais[2];
+    const agora = new Date().toISOString();
+    if (bruta !== undefined) {
+        const lido = (0, pulse_resposta_1.interpretarRespostaDoPulse)(bruta.trim().startsWith('#') ? bruta : `#${bruta.trim()}`);
+        if (lido.forma !== 'cadencia') {
+            throw new Error(`pulse cadencia: tag desconhecida "${bruta}"; use ${Object.keys(pulse_cadencia_1.CADENCIAS).join(', ')}`);
+        }
+        (0, pulse_cadencia_1.gravarCadencia)(carregado.raiz, lido.tag, { por: texto(args.opcoes.por) ?? (0, node_os_1.userInfo)().username,
+            canal: texto(args.opcoes.canal) ?? 'terminal', em: agora });
+    }
+    const vigente = (0, pulse_cadencia_1.lerCadencia)(carregado.raiz);
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify({ tag: vigente.tag, janelaMin: vigente.janelaMin, ancoraMin: vigente.ancoraMin,
+            descricao: vigente.descricao, gravada: vigente.gravada, proximaJanela: (0, pulse_cadencia_1.inicioDaProximaJanela)(vigente, agora) }, null, 2));
+        return 0;
+    }
+    console.log((0, pulse_cadencia_1.textoDaCadencia)(vigente, agora));
+    console.log(vigente.gravada
+        ? `Trocada por ${vigente.gravada.por} (${vigente.gravada.canal}) em ${(0, horario_1.formatarDataHoraRotulada)(vigente.gravada.em)}.`
+        : 'Nenhuma tag gravada: vale a cadência padrão.');
+    return 0;
+}
 function comandoClaims(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
@@ -522,6 +1345,11 @@ function comandoClaims(args) {
             console.log('');
             console.log('AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.');
         }
+        // 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('');
+            console.log(`AVISO: ${(0, claim_lint_1.linhaDoLintDeClaim)(claim.id, a)}${a.regra === 'suite-inteira' ? '. O `ci prepare` recusa esta claim.' : ''}`);
+        }
         return 0;
     }
     if (sub === 'verificar') {
@@ -555,6 +1383,19 @@ function comandoClaims(args) {
         console.log('  o historico da alegacao continua no claims.jsonl e no ledger.');
         return 0;
     }
+    if (sub === 'ausente') {
+        const id = args.posicionais[2];
+        const paths = (texto(args.opcoes.paths) ?? '').split(',').map((p) => p.trim()).filter(Boolean);
+        const motivo = texto(args.opcoes.motivo);
+        if (!id || paths.length === 0 || !motivo) {
+            console.error('uso: ork claims ausente <thread-id> --paths A,B --motivo "<motivo>" [--commit SHA]');
+            return 2;
+        }
+        (0, prova_minima_1.registrarProvaAusente)(carregado.raiz, id, { paths, motivo, commit: texto(args.opcoes.commit) });
+        console.log(`Ausencia de prova registrada na thread ${id}: ${paths.join(', ')}.`);
+        console.log(`  motivo     ${motivo}`);
+        return 0;
+    }
     if (sub === 'list' || sub === undefined) {
         const id = args.posicionais[2];
         if (!id) {
@@ -571,11 +1412,12 @@ function comandoVerify(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const id = args.posicionais[1];
     if (!id) {
-        console.error('uso: ork verify <thread-id> [--baseline] [--so-claims]');
+        console.error('uso: ork verify <thread-id> [--baseline] [--so-claims] [--canal C] [--esperar [min]]');
         return 2;
     }
+    const conducao = conducaoDoCli(args);
     if (args.opcoes.baseline === true) {
-        const b = (0, verify_1.gravarBaseline)(carregado, id);
+        const b = (0, verify_1.gravarBaseline)(carregado, id, undefined, conducao);
         console.log(`Baseline gravada para a thread ${id}.`);
         console.log(`  commit ${b.commit}`);
         for (const c of b.comandos) {
@@ -586,13 +1428,67 @@ function comandoVerify(args) {
         }
         return 0;
     }
-    const r = (0, verify_1.verificar)(carregado, id, { soClaims: args.opcoes['so-claims'] === true });
+    const r = (0, verify_1.verificar)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao });
     console.log((0, verify_1.textoDoVerify)(r));
     return r.ok ? 0 : 1;
 }
+/**
+ * `ork conducao status|assumir` (I-36, T15): quem conduz a thread agora, e o handoff explicito. O
+ * status tambem libera, com prova no ledger, a conducao que ficou sem dono (T16).
+ */
+function comandoConducao(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    const id = args.posicionais[2];
+    if (sub === 'status') {
+        if (!id)
+            throw new Error('uso: ork conducao status <thread-id> [--json]');
+        (0, thread_1.lerThread)(carregado.raiz, id);
+        (0, conducao_1.liberarSeOrfa)(carregado.raiz, id);
+        const atual = (0, conducao_1.conducaoDaThread)(carregado.raiz, id);
+        console.log(args.opcoes.json === true ? JSON.stringify({ thread: id, conducao: atual }, null, 2) : (0, conducao_1.textoDoStatusDaConducao)(id, atual));
+        return 0;
+    }
+    if (sub === 'assumir') {
+        const por = texto(args.opcoes.por), motivo = texto(args.opcoes.motivo);
+        if (!id || !por || !motivo)
+            throw new Error('uso: ork conducao assumir <thread-id> --por <quem> --motivo "<por que>" [--canal C]');
+        const r = (0, conducao_1.assumirConducao)(carregado.raiz, id, { por, motivo, canal: conducaoDoCli(args).canal });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : `${r.ok ? 'Conducao assumida.' : 'Handoff recusado.'} ${r.detalhe}`);
+        return r.ok ? 0 : 3;
+    }
+    throw new Error('uso: ork conducao status|assumir <thread-id>');
+}
 function comandoGate(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
+    if (sub === 'context') {
+        const id = args.posicionais[2], pedido = args.posicionais[3];
+        if (!id || !pedido || args.posicionais.length !== 4 ||
+            Object.entries(args.opcoes).some(([k, v]) => k !== 'native-offer-stdin' || v !== true))
+            throw Error('uso: ork gate context <thread> <pedido> [--native-offer-stdin]');
+        const view = (0, hitl_gates_1.contextoDoPedidoNativo)(carregado.raiz, id, pedido);
+        const callback = args.opcoes['native-offer-stdin'] ? (0, hitl_native_offer_1.readNativeOfferStdin)() : undefined;
+        console.log(JSON.stringify({ ...view, canais: (0, hitl_presentation_1.ofertaDoPedido)(view.pedido, [], callback === undefined ? undefined : { callback, raiz: carregado.raiz }),
+            apresentacao: (0, hitl_presentation_1.apresentarDecisao)(view.pedido), prazoLocal: (0, hitl_presentation_1.prazoLocalDoPedido)(view.pedido) }));
+        return 0;
+    }
+    if (sub === 'request') {
+        const id = args.posicionais[2];
+        if (!id)
+            throw new Error('gate request exige thread');
+        console.log(JSON.stringify((0, hitl_gates_1.abrirPedidoGate)(carregado.raiz, id, texto(args.opcoes.motivo))));
+        return 0;
+    }
+    if (sub === 'answer') {
+        const id = args.posicionais[2], pedido = args.posicionais[3];
+        if (!id || !pedido || args.opcoes['resposta-stdin'] !== true || args.opcoes.resposta !== undefined)
+            throw new Error('gate answer exige thread, pedido e --resposta-stdin');
+        const r = (0, hitl_gates_1.lerRespostaStdin)({ por: texto(args.opcoes.por), mensagem: texto(args.opcoes.mensagem),
+            origem: texto(args.opcoes.origem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
+        console.log(JSON.stringify((0, hitl_gates_1.responderGate)(carregado.raiz, id, pedido, r)));
+        return 0;
+    }
     if (sub === 'next') {
         const id = args.posicionais[2];
         if (!id) {
@@ -620,7 +1516,7 @@ function comandoGate(args) {
         const sobre = args.posicionais[3];
         const por = texto(args.opcoes.por) ?? texto(args.opcoes.quem);
         if (!id || !sobre || !por) {
-            console.error('uso: ork gate approve <thread-id> <sobre> --por <quem>');
+            console.error('gate approve aposentado: aprovação sem pedido é recusada. Use ork gate request <thread-id> e responda pelo ingresso humano autenticado.');
             return 2;
         }
         (0, thread_1.lerThread)(carregado.raiz, id);
@@ -628,7 +1524,7 @@ function comandoGate(args) {
         console.log(`Autorizacao humana registrada no ledger da thread ${id}.`);
         console.log(`  sobre          ${sobre}`);
         console.log(`  autorizado por ${por}`);
-        console.log(`  quando         ${e.ts}`);
+        console.log(`  quando         ${(0, horario_1.formatarDataHoraRotulada)(e.ts)}`);
         return 0;
     }
     console.error(`subcomando desconhecido: gate ${sub}`);
@@ -694,7 +1590,7 @@ function comandoRetry(args) {
         }
         console.log('Sinal de rate limit reconhecido no stderr do runtime:');
         console.log(`  fonte da hora  ${sinal.fonte}`);
-        console.log(`  reset em       ${sinal.resetEm ?? '(o runtime nao disse a hora)'}`);
+        console.log(`  reset em       ${sinal.resetEm ? (0, horario_1.formatarDataHoraRotulada)(sinal.resetEm) : '(o runtime nao disse a hora)'}`);
         console.log(`  trecho         ${sinal.trecho}`);
         if (sinal.resetEm === null) {
             console.log('');
@@ -704,6 +1600,7 @@ function comandoRetry(args) {
         return 0;
     }
     const carregado = (0, manifest_1.exigirManifesto)();
+    avisarChavesDePerfis(carregado);
     if (sub === 'plan' || sub === 'run') {
         const id = args.posicionais[2];
         if (!id) {
@@ -726,6 +1623,10 @@ function comandoRetry(args) {
             console.log((0, retry_1.textoDoPlano)(plano));
             return 0;
         }
+        // I-36 (D2): `--esperar` espera a conducao em andamento terminar antes de executar a retomada.
+        const conducao = conducaoDoCli(args);
+        if (conducao.esperarMs && args.opcoes['dry-run'] !== true)
+            (0, conducao_1.esperarConducaoLivre)(carregado.raiz, id, conducao.esperarMs);
         const r = (0, retry_1.executarRetry)(carregado, id, {
             ...opcoes,
             dryRun: args.opcoes['dry-run'] === true,
@@ -750,7 +1651,7 @@ function comandoRetry(args) {
         const espera = (0, ratelimit_1.lerFilaDeRetomada)(carregado.raiz).filter((p) => p.estado === 'aguardando');
         if (espera.length > 0) {
             console.log('');
-            console.log(`Proxima janela: ${espera[0].liberaEm} (${(0, ratelimit_1.faltaPara)(espera[0])}).`);
+            console.log(`Proxima janela: ${(0, horario_1.formatarDataHora)(espera[0].liberaEm)} (${(0, ratelimit_1.faltaPara)(espera[0])}).`);
             console.log('Retome com: ork retry resume');
         }
         return 0;
@@ -810,9 +1711,10 @@ function comandoFix(args) {
             console.error('uso: ork fix open <thread-id> [--so-claims] [--reverify]');
             return 2;
         }
-        const rodada = (0, fix_1.abrirRodada)(carregado, id, { soClaims: args.opcoes['so-claims'] === true });
+        const conducao = conducaoDoCli(args);
+        const rodada = (0, fix_1.abrirRodada)(carregado, id, { soClaims: args.opcoes['so-claims'] === true, conducao });
         const reverify = args.opcoes.reverify === true && rodada.correcoes.length > 0
-            ? (0, fix_1.reverificar)(carregado, id, { rodada: rodada.rodada })
+            ? (0, fix_1.reverificar)(carregado, id, { rodada: rodada.rodada, conducao })
             : null;
         if (args.opcoes.json === true) {
             console.log(JSON.stringify({ rodada, reverify }, null, 2));
@@ -864,6 +1766,7 @@ function comandoFix(args) {
         }
         const rodadaBruta = texto(args.opcoes.rodada);
         const r = (0, fix_1.reverificar)(carregado, id, {
+            conducao: conducaoDoCli(args),
             rodada: rodadaBruta ? Number(rodadaBruta) : undefined,
             parcial: args.opcoes.parcial === true,
         });
@@ -918,6 +1821,30 @@ function comandoHandoff(args) {
 }
 function comandoShip(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
+    if (args.posicionais[1] === 'registrar-pr') {
+        // I-57 (RM-008): a entrega feita por PR vira ship_done, provada no remoto e no CI.
+        const alvo = args.posicionais[2];
+        const remoto = texto(args.opcoes.remoto);
+        if (!alvo && args.opcoes.todas !== true) {
+            console.error('uso: ork ship registrar-pr <thread-id> | --todas [--remoto R] [--json]');
+            return 2;
+        }
+        const r = alvo ? [(0, entrega_pr_1.registrarEntregaPorPr)(carregado, alvo, { remoto })] : (0, entrega_pr_1.registrarEntregasPorPr)(carregado, { remoto });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(r, null, 2));
+            return r.some((x) => x.acao === 'recusada') ? 1 : 0;
+        }
+        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}`);
+        const registradas = r.filter((x) => x.acao === 'registrou').length;
+        if (registradas) {
+            console.log('');
+            console.log(`${registradas} entrega(s) registrada(s). Fechar pelo MASTER: ork master --aceitar-omissao (a nota humana sobrescreve).`);
+        }
+        return r.some((x) => x.acao === 'recusada') ? 1 : 0;
+    }
     const id = args.posicionais[1];
     const para = texto(args.opcoes.para) ?? texto(args.opcoes.to);
     if (!id || !para) {
@@ -937,6 +1864,190 @@ function comandoShip(args) {
     console.log((0, ship_1.textoDoShip)(r));
     return r.ok ? 0 : 1;
 }
+function comandoPortfolio(args) {
+    const root = (0, manifest_1.exigirManifesto)().raiz;
+    const sub = args.posicionais[1] ?? 'list';
+    if (sub === 'inspect') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork portfolio inspect <id> --json');
+            return 2;
+        }
+        console.log(JSON.stringify((0, portfolio_context_1.inspectPortfolio)(root, id), null, 2));
+        return 0;
+    }
+    const aliases = { product: 'product', project: 'project', initiative: 'initiative', prod: 'product', proj: 'project', init: 'initiative' };
+    const split = (value, separator = ',') => value?.split(separator).map((item) => item.trim()).filter(Boolean) ?? [];
+    if (sub === 'list') {
+        const rawKind = args.posicionais[2];
+        const kind = rawKind ? aliases[rawKind] : undefined;
+        if (rawKind && !kind) {
+            console.error('tipo deve ser product, project ou initiative');
+            return 2;
+        }
+        const items = (0, portfolio_1.listEntities)(root, kind, texto(args.opcoes.parent));
+        console.log(args.opcoes.json === true ? JSON.stringify({ schema: 'ork.portfolio-list/v1', updatedAt: (0, portfolio_1.readPortfolio)(root).updatedAt, items }, null, 2)
+            : items.length ? items.map((item) => `${item.id}\t${item.kind}\t${item.status}\t${item.title}`).join('\n') : 'Portfólio vazio.');
+        return 0;
+    }
+    if (sub === 'show') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork portfolio show <id>');
+            return 2;
+        }
+        const item = (0, portfolio_1.findEntity)(root, id);
+        if (!item) {
+            console.error(`entidade ${id} não encontrada`);
+            return 1;
+        }
+        console.log(args.opcoes.json === true ? JSON.stringify(item, null, 2) : `${item.id}\n${item.title}\nEstado: ${item.status}`);
+        return 0;
+    }
+    if (sub === 'create') {
+        const kind = aliases[args.posicionais[2] ?? ''];
+        const id = args.posicionais[3], title = texto(args.opcoes.title), parent = texto(args.opcoes.parent);
+        if (!kind || !id || !title) {
+            console.error('uso: ork portfolio create <product|project|initiative> <id> --title T [--parent ID]');
+            return 2;
+        }
+        const common = { id, title, description: texto(args.opcoes.description), ownerId: texto(args.opcoes.owner), status: texto(args.opcoes.status), acceptanceCriteria: split(texto(args.opcoes.acceptance), ';') };
+        const item = kind === 'product' ? (0, portfolio_1.createProduct)(root, common)
+            : kind === 'project' ? (0, portfolio_1.createProject)(root, { ...common, productId: parent ?? '', workspaceIds: split(texto(args.opcoes.workspaces)) })
+                : (0, portfolio_1.createInitiative)(root, { ...common, projectId: parent ?? '', dependsOn: split(texto(args.opcoes.depends)) });
+        console.log(JSON.stringify({ schema: 'ork.portfolio-created/v1', item }, null, 2));
+        return 0;
+    }
+    console.error(`subcomando desconhecido: portfolio ${sub}`);
+    return 2;
+}
+function comandoCreation(args) {
+    const loaded = (0, manifest_1.exigirManifesto)();
+    // CLI local opera com a autoridade do usuário do SO, assim como portfolio create.
+    // Fachadas HTTP devem usar a API com principal e authorize autenticados no servidor.
+    const actor = { principal: `local:uid:${(0, node_os_1.userInfo)().uid}`, authorize: () => { } };
+    const sub = args.posicionais[1], id = args.posicionais[2];
+    if (args.opcoes.principal !== undefined || args.opcoes.por !== undefined)
+        throw new Error('creation.identity: payload não escolhe principal');
+    let result;
+    if (sub === 'session') {
+        const portfolio = (0, portfolio_1.readPortfolio)(loaded.raiz);
+        result = {
+            schema: 'ork.creation-session/v1', principal: actor.principal,
+            workspaceIds: [...new Set(portfolio.projects.flatMap((project) => project.workspaceIds))].sort(),
+            modes: loaded.manifesto.conduction.allowed_modes,
+            actions: ['create_entity', 'create_entity_with_ticket', 'open_ticket'],
+        };
+    }
+    else if (sub === 'start') {
+        const file = texto(args.opcoes['input-file']);
+        if (!file) {
+            console.error('uso: ork creation start --input-file F --json');
+            return 2;
+        }
+        const content = fs.readFileSync(file, 'utf8');
+        if (Buffer.byteLength(content) > 100_000)
+            throw new Error('creation.input: arquivo excede limite');
+        result = (0, creation_operation_1.startCreation)(loaded, actor, JSON.parse(content));
+    }
+    else if (sub === 'list')
+        result = (0, creation_operation_store_1.listCreationOperations)(loaded.raiz, actor.principal);
+    else if (!id) {
+        console.error('creation exige id');
+        return 2;
+    }
+    else if (sub === 'show' || sub === 'events') {
+        const op = (0, creation_operation_store_1.readCreationOperation)(loaded.raiz, id, actor.principal);
+        result = sub === 'events' ? { schema: 'ork.creation-events/v1', operationId: id, version: op.version, events: op.events } : op;
+    }
+    else if (sub === 'resume' || sub === 'compensate') {
+        const version = Number(texto(args.opcoes['expected-version']));
+        if (!Number.isSafeInteger(version) || version < 1) {
+            console.error('creation exige --expected-version inteiro positivo');
+            return 2;
+        }
+        result = sub === 'resume' ? (0, creation_operation_1.resumeCreation)(loaded, actor, id, version) : (0, creation_operation_1.compensateCreation)(loaded, actor, id, version);
+    }
+    else {
+        console.error('subcomando creation desconhecido');
+        return 2;
+    }
+    console.log(JSON.stringify(result, null, 2));
+    return 0;
+}
+/**
+ * `ork objective`: APOSENTADO na I-43 (D4).
+ *
+ * O Objective Envelope descrevia um gate que nao bloqueava nada, e a medida foi mais
+ * dura que a suspeita do GOAL: das 137 threads do projeto, ZERO tinham
+ * `creationOrigin`, e `creationOrigin` era a unica via pela qual `phase.ts` consultava
+ * o envelope. O ramo nunca disparou para thread nenhuma. Havia um envelope em disco,
+ * `obj-i27gatedomae`, em `awaiting_approval` desde 17/09, com tres threads de zero
+ * sessoes: a unica pausa do `#Maestro` nao bloqueava o despacho das proprias threads
+ * que ela criou, e aprova-la nao teria efeito.
+ *
+ * As DUAS VIGAS que ele guardava sairam vivas, e viraram propriedade de thread comum:
+ *   - validacao por runtime diferente -> `thread.exigeRuntimeDiferente` (T9);
+ *   - `doneWhen` executavel -> `thread.doneWhen`, que vira claim do nucleo (T10).
+ *
+ * A recusa e TIPADA e diz para onde ir. Sumir em silencio seria o mesmo pecado da
+ * #TAG aposentada virando default: quem tem o comando num script precisa saber.
+ */
+function comandoObjective(args) {
+    const sub = args.posicionais[1] ?? 'list';
+    console.error(`objective.aposentado: o Objective Envelope saiu do produto na I-43 (subcomando "${sub}").\n` +
+        '  Ele descrevia um gate que nao bloqueava nada: das 137 threads do projeto, zero\n' +
+        '  tinham creationOrigin, que era a unica via pela qual o despacho o consultava.\n' +
+        '  As duas vigas que ele guardava viraram propriedade de thread comum:\n' +
+        '    ork thread new "<nome>" --modo <MODO> --exige-runtime-diferente\n' +
+        '        o CHECK precisa de runtime que o GO nao usou\n' +
+        '    ork thread new "<nome>" --modo <MODO> --done "<criterio> :: <comando>"\n' +
+        '        criterio de pronto EXECUTAVEL, que vira claim e roda no ork verify\n' +
+        '  Os envelopes ja gravados continuam em .orkastery/objectives, intocados.');
+    return 2;
+}
+function comandoCi(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1] ?? 'status';
+    if (sub === 'prepare') {
+        const thread = args.posicionais[2];
+        if (!thread) {
+            console.error('uso: ork ci prepare <thread-id>');
+            return 2;
+        }
+        const arquivo = (0, ci_1.prepararBundleCi)(carregado, thread, { aoAvisar: (linha) => console.log(`AVISO: ${linha}`) });
+        console.log(`Bundle de CI: ${arquivo}`);
+        return 0;
+    }
+    if (sub === 'run') {
+        const bundle = texto(args.opcoes.bundle);
+        if (bundle) {
+            const result = (0, ci_1.executarBundleCi)(carregado, bundle);
+            console.log(JSON.stringify(result, null, 2));
+            return result.ok ? 0 : 1;
+        }
+        const thread = args.posicionais[2];
+        if (!thread) {
+            console.error('uso: ork ci run <thread-id> [--json] | ork ci run --bundle <arquivo>');
+            return 2;
+        }
+        const result = (0, ci_1.executarCi)(carregado, thread);
+        console.log(args.opcoes.json === true ? JSON.stringify(result, null, 2) : `${result.status.ok ? 'CI APROVADO' : 'CI REPROVADO'}: ${result.status.detail}`);
+        return result.status.ok ? 0 : 1;
+    }
+    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]');
+            return 2;
+        }
+        const result = (0, ci_1.consultarCi)(carregado, sha, texto(args.opcoes.remoto) ?? 'origin');
+        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;
+    }
+    console.error(`subcomando desconhecido: ci ${sub}`);
+    return 2;
+}
 function comandoLease(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
@@ -956,14 +2067,14 @@ function comandoLease(args) {
         const r = (0, leases_1.adquirirRegiao)(carregado.raiz, nome, { thread, motivo });
         if (r.ok) {
             console.log(`Lease ${r.nome} [${r.tipo}] adquirido pela thread ${thread}.`);
-            console.log(`  expira em ${r.lease?.expiraEm}`);
+            console.log(`  expira em ${(0, horario_1.formatarDataHoraRotulada)(r.lease?.expiraEm)}`);
             if (r.tomadoDeVencido)
                 console.log('  (o lease anterior estava VENCIDO e foi tomado)');
             return 0;
         }
         console.error(`Lease ${r.nome} NAO adquirido.`);
         console.error(`  motivo tipado: ${r.motivo}`);
-        console.error(`  detalhe: ${r.detalhe}`);
+        console.error(`  detalhe: ${(0, horario_1.localizarTextoRotulado)(r.detalhe)}`);
         console.error(`  posicao na fila: ${r.posicaoNaFila}`);
         console.error(`  correcao: ${r.correcao}`);
         return 1;
@@ -985,14 +2096,105 @@ function comandoBoard(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const sub = args.posicionais[1];
     if (sub === 'plan' || sub === 'plano') {
-        console.log((0, board_1.textoDoPlano)((0, board_1.planejar)(carregado)));
+        const plano = (0, board_1.planejar)(carregado);
+        console.log(args.opcoes.json === true ? JSON.stringify(plano, null, 2) : (0, board_1.textoDoPlano)(plano));
+        return 0;
+    }
+    if (sub === 'reap') {
+        const devolvidas = (0, board_1.devolverVagas)(carregado, { por: texto(args.opcoes.por) });
+        if (args.opcoes.json === true)
+            console.log(JSON.stringify(devolvidas, null, 2));
+        else
+            console.log((0, board_1.textoDoReap)(devolvidas));
         return 0;
     }
     if (sub !== undefined && sub !== 'list') {
         console.error(`subcomando desconhecido: board ${sub}`);
+        console.error('uso: ork board [list|plan|reap] [--all] [--por <quem>] [--json]');
         return 2;
     }
-    console.log((0, board_1.textoDoBoard)(carregado, args.opcoes.all === true || args.opcoes.todos === true));
+    const todos = args.opcoes.all === true || args.opcoes.todos === true;
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify((0, board_1.threadsDeTodosOsPerfis)(carregado, todos), null, 2));
+        return 0;
+    }
+    console.log((0, board_1.textoDoBoard)(carregado, todos));
+    // I-51 (RM-047): com a fabrica compartilhada, o board mostra tambem as outras maquinas.
+    if ((0, maquina_1.fabricaCompartilhada)(carregado.manifesto)) {
+        const painel = (0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto: carregado.manifesto.fabrica.remoto,
+            semRemoto: args.opcoes['sem-remoto'] === true });
+        console.log('');
+        console.log((0, fabrica_estado_1.textoDasOutrasMaquinas)(painel, (0, maquina_1.nomeDaMaquina)()));
+    }
+    return 0;
+}
+/**
+ * I-51 (RM-047): `ork fabrica` mostra o que cada maquina conduz; `ork fabrica publicar` grava o
+ * retrato desta maquina na branch `ork/fabrica-estado`. O `--silencioso` e o da publicacao em
+ * segundo plano: nada no terminal, uma linha em `.orkastery/monitor/fabrica.log`.
+ */
+function comandoFabrica(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    const remoto = texto(args.opcoes.remoto) ?? carregado.manifesto.fabrica.remoto;
+    if (sub === 'publicar') {
+        const silencioso = args.opcoes.silencioso === true;
+        try {
+            const r = (0, fabrica_estado_1.publicarMaquina)(carregado, { remoto, forcar: args.opcoes.forcar === true });
+            if (silencioso) {
+                (0, fabrica_estado_1.registrarPublicacao)(carregado.raiz, { ...r });
+                return 0;
+            }
+            if (args.opcoes.json === true)
+                console.log(JSON.stringify(r, null, 2));
+            else
+                console.log(r.acao === 'publicou'
+                    ? `Fabrica: ${r.maquina} publicou ${r.threads} thread(s) em ork/fabrica-estado (${r.commit?.slice(0, 7)}, ${r.tentativas} tentativa(s)).`
+                    : r.acao === 'ocupado'
+                        ? `Fabrica: outra publicacao desta maquina esta em andamento; tente de novo em instantes.`
+                        : `Fabrica: retrato de ${r.maquina} igual ao ultimo publicado; nada a enviar (use --forcar para publicar mesmo assim).`);
+            if (!(0, maquina_1.fabricaCompartilhada)(carregado.manifesto) && !silencioso) {
+                console.log('  esta maquina nao entrou na fabrica compartilhada: so publica quando voce pede (ork fabrica entrar liga).');
+            }
+            return 0;
+        }
+        catch (e) {
+            if (silencioso) {
+                (0, fabrica_estado_1.registrarPublicacao)(carregado.raiz, { acao: 'falhou', erro: e.message });
+                return 1;
+            }
+            throw e;
+        }
+    }
+    if (sub === 'entrar') {
+        // A adesao e o nome ficam no arquivo do usuario: valem para o shell, o cron e os gateways.
+        const config = (0, maquina_1.gravarConfigDaMaquina)({ nome: texto(args.opcoes.maquina) ?? (0, maquina_1.lerConfigDaMaquina)()?.nome ?? (0, maquina_1.nomeDaMaquina)(),
+            fabricaCompartilhada: true });
+        const r = (0, fabrica_estado_1.publicarMaquina)(carregado, { remoto, forcar: true });
+        console.log(`Fabrica: esta maquina entrou como ${config.nome}; publica ao criar thread, despachar fase, entregar e fechar,`);
+        console.log(`  e a cada batida do pulse. Primeiro retrato: ${r.threads} thread(s) em ork/fabrica-estado (${r.commit?.slice(0, 7)}).`);
+        if (process.env.ORK_MAQUINA && process.env.ORK_MAQUINA.trim() !== config.nome) {
+            console.log(`  AVISO: ORK_MAQUINA=${process.env.ORK_MAQUINA} neste shell vence o arquivo; alinhe os dois.`);
+        }
+        return 0;
+    }
+    if (sub === 'sair') {
+        const config = (0, maquina_1.gravarConfigDaMaquina)({ fabricaCompartilhada: false });
+        const r = (0, fabrica_estado_1.removerMaquina)(carregado, { remoto });
+        console.log(`Fabrica: ${(0, maquina_1.nomeDaMaquina)()} saiu; nada mais e publicado daqui.` +
+            (r ? ` Retrato removido de ork/fabrica-estado (${r.slice(0, 7)}).` : ' Nao havia retrato desta maquina na branch.'));
+        if ((0, maquina_1.fabricaCompartilhada)(carregado.manifesto))
+            console.log('  AVISO: o manifesto do projeto (ou ORK_FABRICA_COMPARTILHADA) ainda liga a fabrica aqui.');
+        void config;
+        return 0;
+    }
+    if (sub !== undefined && sub !== 'list') {
+        console.error(`subcomando desconhecido: fabrica ${sub}`);
+        console.error('uso: ork fabrica [--json] [--sem-remoto] | fabrica publicar [--forcar] [--json] | fabrica entrar [--maquina NOME] | fabrica sair');
+        return 2;
+    }
+    const painel = (0, fabrica_estado_1.lerFabrica)(carregado.raiz, { remoto, semRemoto: args.opcoes['sem-remoto'] === true });
+    console.log(args.opcoes.json === true ? JSON.stringify(painel, null, 2) : (0, fabrica_estado_1.textoDaFabrica)(painel, (0, maquina_1.nomeDaMaquina)()));
     return 0;
 }
 /**
@@ -1105,15 +2307,95 @@ function comandoWorktree(args) {
 function comandoMaster(args) {
     const carregado = (0, manifest_1.exigirManifesto)();
     const primeiro = args.posicionais[1];
+    if (primeiro === 'audit') {
+        const r = (0, master_audit_1.auditarMaster)(carregado.raiz);
+        console.log(JSON.stringify(r, null, 2));
+        return r.ok ? 0 : 1;
+    }
+    if (primeiro === 'digest') {
+        const sub = args.posicionais[2];
+        if (sub === 'responder') {
+            console.log(JSON.stringify((0, master_digest_1.responderLoteDigest)(carregado.raiz, texto(args.opcoes.resposta) ?? '', texto(args.opcoes.por) ?? '').map(r => ({ thread: r.thread.id, score: r.masterLog.score })), null, 2));
+            return 0;
+        }
+        if (sub === 'preview') {
+            console.log(JSON.stringify((0, master_digest_1.montarDigest)(carregado.raiz, new Date().toISOString()), null, 2));
+            return 0;
+        }
+        if (sub !== 'enviar')
+            throw new Error('uso: ork master digest <enviar|preview|responder>');
+        const r = (0, master_digest_1.enviarDigest)({ raiz: carregado.raiz });
+        console.log(JSON.stringify(r, null, 2));
+        return r.code;
+    }
+    if (primeiro === 'migrar') {
+        console.log(JSON.stringify((0, master_migracao_1.migrarMaster)(carregado.raiz, { dryRun: args.opcoes['dry-run'] === true, por: texto(args.opcoes.por) ?? '' }), null, 2));
+        return 0;
+    }
     if (primeiro === 'classes') {
-        console.log((0, master_1.tabelaDeClasses)());
+        console.log((0, master_2.tabelaDeClasses)());
         return 0;
     }
-    if (args.opcoes.batch === true || primeiro === 'batch' || primeiro === undefined) {
-        console.log((0, master_1.tabelaDeBatch)(carregado.raiz, args.opcoes.todas === true));
+    if (primeiro === 'ratificar' || ((args.opcoes.batch === true || primeiro === 'batch') && args.opcoes.aceitar)) {
+        let selecao;
+        if (primeiro === 'ratificar') {
+            const partes = (texto(args.opcoes.resposta) ?? '').trim().split(/\s+/);
+            const classe = (0, master_2.parseClasse)(partes[3]);
+            if (partes.length !== 4 || partes[0] !== 'ratificar' || !classe)
+                throw new Error('resposta deve ser ratificar <thread> <assinatura> <classe>');
+            selecao = [{ thread: partes[1], assinatura: partes[2], classe }];
+        }
+        else {
+            selecao = (texto(args.opcoes.aceitar) ?? '').split(',').map(v => {
+                const partes = v.trim().split(':');
+                if (partes.length !== 2 || !/^[a-f0-9]{64}$/.test(partes[1]))
+                    throw new Error('seleção deve ser thread:assinatura');
+                return { thread: partes[0], assinatura: partes[1] };
+            });
+        }
+        console.log(JSON.stringify((0, master_batch_1.ratificarBatch)(carregado.raiz, selecao, texto(args.opcoes.por) ?? '').map(r => ({ thread: r.thread.id, score: r.masterLog.score, por: r.masterLog.avaliadoPor })), null, 2));
         return 0;
     }
-    const id = primeiro;
+    // I-43 (T8): a FILA saiu. `--batch` recebe recusa tipada em vez de sumir em
+    // silencio: quem tem o comando no dedo ou num script precisa SABER que o regime
+    // mudou, e para onde ir. Desaparecer sem dizer nada seria o mesmo pecado da #TAG
+    // aposentada virando default.
+    if (args.opcoes.batch === true || primeiro === 'batch') {
+        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> --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 (primeiro === undefined) {
+        console.log(args.opcoes.json
+            ? JSON.stringify({ entregas: (0, master_batch_1.listarBatch)(carregado.raiz, args.opcoes.todas === true),
+                aceitasPorOmissao: (0, master_2.aceitosPorOmissao)(carregado.raiz) }, null, 2)
+            : (0, master_2.tabelaDeEntregas)(carregado.raiz, args.opcoes.todas === true));
+        return 0;
+    }
+    const propor = primeiro === 'propor';
+    const id = propor ? args.posicionais[2] : primeiro;
+    if (!id)
+        throw new Error('informe a thread para propor MASTER');
     const brutoScore = texto(args.opcoes.score);
     const justificativa = texto(args.opcoes.justificativa) ?? texto(args.opcoes.porque);
     if (brutoScore === undefined) {
@@ -1130,28 +2412,51 @@ function comandoMaster(args) {
     const brutasClasses = texto(args.opcoes.classe) ?? texto(args.opcoes.classes);
     const classes = [];
     for (const bruta of (brutasClasses ?? '').split(',').map((c) => c.trim()).filter(Boolean)) {
-        const classe = (0, master_1.parseClasse)(bruta);
+        const classe = (0, master_2.parseClasse)(bruta);
         if (!classe) {
             console.error(`classe de falha invalida: "${bruta}".`);
-            console.error(`  classes fixas: ${master_1.ORDEM_DAS_CLASSES.join(', ')}`);
+            console.error(`  classes fixas: ${master_2.ORDEM_DAS_CLASSES.join(', ')}`);
             return 2;
         }
         classes.push(classe);
     }
-    const r = (0, master_1.registrarMaster)(carregado.raiz, id, {
+    const opcoesMaster = {
         score: Number(brutoScore),
         justificativa,
         classes,
         resumo: texto(args.opcoes.resumo),
         por: texto(args.opcoes.por) ?? texto(args.opcoes.quem),
         refazer: args.opcoes.refazer === true,
-    });
-    console.log((0, master_1.textoDoMaster)(r));
+    };
+    if (propor) {
+        console.log(JSON.stringify((0, master_1.proporMaster)(carregado.raiz, id, opcoesMaster), null, 2));
+        return 0;
+    }
+    const r = (0, master_2.registrarMaster)(carregado.raiz, id, opcoesMaster);
+    console.log((0, master_2.textoDoMaster)(r));
     // Bloco B6: fechada a thread, a licao (POSTMORTEM + score) vai para a colecao
     // `learning`, e e o que uma thread NOVA do mesmo produto recebe no GOAL.
     relatarPublicacao((0, memoria_1.publicar)(carregado, id));
+    // I-55 (RM-008): a thread fechada pode fazer uma falha recorrente passar do piso. A proposta
+    // vai ao ledger do projeto uma vez por janela; virar policy continua sendo do dono.
+    for (const p of (0, licoes_1.registrarPropostasNovas)(carregado.raiz)) {
+        console.log('');
+        console.log(`Proposta de policy: ${p.chave} em ${p.threads.length} threads nos ultimos ${p.janelaDias} dias.`);
+        console.log(`  ${p.sugestao}`);
+        console.log('  So proposta: vira policy quando voce a declara em policies: no orkastery.yaml (ork licoes).');
+    }
     console.log('');
-    console.log(`Proximo passo: ork board --all   |   fila de score: ork master --batch`);
+    console.log(`Proximo passo: ork board --all   |   entregas e indice: ork master`);
+    return 0;
+}
+/** 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)();
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify({ resumo: (0, licoes_1.resumoDasLicoes)(carregado.raiz, null), propostas: (0, licoes_1.propostasDePolicy)(carregado.raiz) }, null, 2));
+        return 0;
+    }
+    console.log((0, licoes_1.textoDeLicoes)(carregado.raiz));
     return 0;
 }
 /**
@@ -1161,6 +2466,81 @@ function comandoMaster(args) {
  * exato com o mesmo sha256 que iria para o ledger, para o builder revisar texto sem gastar
  * uma sessao do runtime para descobrir o que foi pedido.
  */
+/**
+ * I-44: documentacao como codigo. `verificar` le docs e git (roda no CI); `sincronizar` le tambem
+ * o estado das threads, que nao e versionado, e por isso roda na maquina do projeto.
+ */
+/** I-47: reservas de item do roadmap entre maquinas (`ork roadmap reservas|pegar|soltar`). */
+function comandoRoadmap(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1] ?? 'reservas';
+    const remoto = texto(args.opcoes.remoto);
+    if (sub === 'reservas') {
+        const painel = (0, roadmap_reservas_1.listarReservas)(carregado.raiz, { remoto });
+        console.log(args.opcoes.json === true ? JSON.stringify(painel, null, 2) : (0, roadmap_reservas_1.textoDasReservas)(painel));
+        return 0;
+    }
+    const item = args.posicionais[2];
+    if ((sub !== 'pegar' && sub !== 'soltar') || !item) {
+        console.error('uso: ork roadmap reservas | pegar <RM-NNN> [--thread T] [--nota N] | soltar <RM-NNN> [--forcar --motivo M]');
+        return 2;
+    }
+    const opcoes = {
+        remoto,
+        por: texto(args.opcoes.por),
+        maquina: texto(args.opcoes.maquina),
+        ...(texto(args.opcoes.thread) !== undefined ? { thread: texto(args.opcoes.thread) } : {}),
+        ...(texto(args.opcoes.nota) !== undefined ? { nota: texto(args.opcoes.nota) } : {}),
+        forcar: args.opcoes.forcar === true,
+        motivo: texto(args.opcoes.motivo),
+    };
+    const r = sub === 'pegar' ? (0, roadmap_reservas_1.pegarItem)(carregado.raiz, item, opcoes) : (0, roadmap_reservas_1.soltarItem)(carregado.raiz, item, opcoes);
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify(r, null, 2));
+        return 0;
+    }
+    const verbo = { pegou: 'reservado para esta maquina', renovou: 'reserva renovada', tomou: 'reserva TOMADA de outra maquina',
+        soltou: 'devolvido', nada: 'ja estava livre' }[r.acao];
+    console.log(`${r.item}: ${verbo}.`);
+    if (r.reserva && r.acao !== 'soltou')
+        console.log(`  com ${r.reserva.por} em ${r.reserva.maquina}${r.reserva.thread ? `, thread ${r.reserva.thread}` : ''}`);
+    if (r.commit)
+        console.log(`  branch ork/roadmap-reservas em ${r.commit.slice(0, 7)}`);
+    return 0;
+}
+function comandoDocs(args) {
+    const sub = args.posicionais[1] ?? 'verificar';
+    const carregado = (0, manifest_1.carregarManifesto)();
+    const raiz = carregado?.raiz ?? process.cwd();
+    const baseBranch = carregado?.manifesto.worktree?.base_branch ?? 'main';
+    if (sub === 'verificar') {
+        const { docs, achados } = (0, docs_1.verificarDocs)(raiz, { baseBranch, ajudaDoCli: AJUDA });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify({ paginas: docs.length, erros: achados.filter((a) => a.gravidade === 'erro').length,
+                achados }, null, 2));
+        }
+        else {
+            console.log((0, docs_1.textoDaVerificacao)(docs, achados));
+        }
+        return achados.some((a) => a.gravidade === 'erro') ? 2 : 0;
+    }
+    if (sub === 'sincronizar') {
+        const escrever = args.opcoes.escrever === true;
+        const r = (0, docs_1.sincronizarDocs)(raiz, { baseBranch, escrever });
+        console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, docs_1.textoDaSincronizacao)(r, escrever));
+        return 0;
+    }
+    if (sub === 'init') {
+        const criados = (0, docs_1.iniciarDocs)(raiz);
+        console.log(criados.length === 0
+            ? 'Documentacao como codigo ja estava no projeto: nada criado.'
+            : ['Criado:', ...criados.map((c) => `  ${c}`), '',
+                '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] | init`);
+    return 2;
+}
 function comandoPrompt(args) {
     const sub = args.posicionais[1] ?? 'list';
     const carregado = (0, manifest_1.carregarManifesto)();
@@ -1186,9 +2566,12 @@ function comandoPrompt(args) {
         // abrir trabalho. Nada e gravado, e o `ork` diz em voz alta que a thread e ficticia.
         if (args.opcoes.exemplo === true || args.opcoes.modo !== undefined || args.opcoes.mode !== undefined) {
             const bruto = texto(args.opcoes.modo) ?? texto(args.opcoes.mode) ?? 'classic';
-            const modo = (0, modos_1.parseModo)(bruto);
-            if (!modo) {
-                console.error(`modo invalido: "${bruto}". Use um de: ${Object.values(modos_1.MODOS).map((m) => m.tag).join(', ')}`);
+            let modo;
+            try {
+                modo = (0, modos_1.exigirModoVivo)(bruto);
+            }
+            catch (e) {
+                console.error(e.message);
                 return 2;
             }
             const exemplo = (0, prompts_1.threadDeExemplo)(modo, fase, carregado?.manifesto.project);
@@ -1266,6 +2649,10 @@ function comandoAdapter(args) {
             force: args.opcoes.force === true || args.opcoes.forcar === true,
             orkBin: texto(args.opcoes.ork),
             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.
+            aceitarCatalogo: (texto(args.opcoes['aceitar-catalogo']) ?? '').split(';').map(x => x.trim()).filter(Boolean),
+            manterCopia: (texto(args.opcoes['manter-copia']) ?? '').split(';').map(x => x.trim()).filter(Boolean),
         });
         console.log((0, hosts_1.textoDaInstalacao)(r));
         return r.ok ? 0 : 2;
@@ -1308,6 +2695,12 @@ function comandoEval(args) {
  * diferente de zero quando reprova, para o agendador do host perceber sem ler texto.
  */
 function comandoAudit(args) {
+    if (args.posicionais[1] === 'process') {
+        const r = (0, process_audit_1.auditarProcesso)((0, manifest_1.exigirManifesto)(), args.opcoes.registrar === true);
+        console.log(JSON.stringify(r, null, 2));
+        const chave = texto(args.opcoes['exigir-achado']);
+        return chave && !r.achados.some(a => a.chave === chave) ? 1 : 0;
+    }
     const sub = args.posicionais[1] ?? 'packs';
     // `audit packs` e `audit lint` funcionam sem manifesto: sao catalogo, nao estado.
     if (sub === 'packs' || sub === 'pack') {
@@ -1673,6 +3066,10 @@ function comandoAudit(args) {
  * que sempre teve. E o que garante que ligar o B6 nao muda o que o builder ja conhece.
  */
 function relatarPublicacao(r) {
+    if (r.publicacao?.estado === 'pendente') {
+        console.log(`Memoria: publicacao pendente (${r.publicacao.motivo}); ativacao explicita necessaria.`);
+        return;
+    }
     if (r.regime !== 'orkmind')
         return;
     const gravados = [
@@ -1687,9 +3084,18 @@ function relatarPublicacao(r) {
     if (r.falhas > 0)
         console.log(`  ${r.falhas} gravacao(oes) nao concluida(s); veja ork memory status.`);
 }
+/** Janela de origem e corte de apresentação são inteiros positivos explícitos. */
+function limiteDeLeitura(valor) {
+    if (valor === undefined)
+        return undefined;
+    if (typeof valor !== 'string' || !/^[0-9]+$/.test(valor) ||
+        Number(valor) < 1 || Number(valor) > 1000)
+        throw Error('memory.query.invalid');
+    return Number(valor);
+}
 /** `ork recall`: recuperacao tardia dos ponteiros do handoff, no momento indicado. */
 function comandoRecall(args) {
-    const carregado = (0, manifest_1.exigirManifesto)();
+    const carregado = (0, project_state_1.memoryState)((0, manifest_1.exigirManifesto)()).loaded;
     const id = args.posicionais[1];
     if (!id) {
         console.error('uso: ork recall <thread-id> [--fase FASE] [--id ptr-N] [--todos] [--forcar]');
@@ -1698,7 +3104,7 @@ function comandoRecall(args) {
     const thread = (0, thread_1.lerThread)(carregado.raiz, id);
     const faseBruta = texto(args.opcoes.fase) ?? texto(args.opcoes.momento);
     const momento = faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined;
-    const memoria = (0, memoria_1.abrirMemoria)(carregado);
+    const memoria = (0, memoria_1.abrirMemoria)(carregado, { leituraRestrita: { thread: id, limite: limiteDeLeitura(args.opcoes.janela) } });
     const r = (0, recall_1.recallDaThread)(carregado, memoria, id, {
         momento,
         id: texto(args.opcoes.id),
@@ -1716,32 +3122,96 @@ function comandoRecall(args) {
 }
 /** `ork memory`: o regime, a publicacao e a busca deterministica por tag. */
 function comandoMemory(args) {
-    const carregado = (0, manifest_1.exigirManifesto)();
+    const candidate = (0, manifest_1.exigirManifesto)();
+    const carregado = (0, project_state_1.memoryState)(candidate).loaded;
     const sub = args.posicionais[1] ?? 'status';
-    const memoria = (0, memoria_1.abrirMemoria)(carregado);
+    const escopo = texto(args.opcoes.escopo)?.split(',').map(s => s.trim());
+    if (sub === 'inventory' || (sub === 'migrate' && args.opcoes['dry-run'] === true)) {
+        const r = (0, memory_migration_1.inventariarHandoffs)(carregado, escopo);
+        if (args.opcoes.json === true)
+            console.log(JSON.stringify(r, null, 2));
+        else {
+            console.log(`Inventario do tenant ${r.tenant}: ${r.incluidos} incluidos, ${r.excluidos} excluidos.`);
+            for (const f of r.fontes)
+                console.log(`  ${f.incluir ? 'incluir' : 'excluir'} ${f.arquivo}: ${f.motivo}`);
+        }
+        return r.fontes.some(f => f.bloqueante) ? 1 : 0;
+    }
+    if (sub === 'migrate') {
+        const operadora = texto(args.opcoes.operadora);
+        if (!operadora || !escopo)
+            throw new Error('scope.write.required: --operadora <thread> --escopo <thread,...>');
+        if (carregado.manifesto.memory.mode === 'orkmind') {
+            const autorizacao = (0, write_activation_1.exigirAtivacao)(carregado, operadora, 'memory');
+            if (escopo.some(id => !autorizacao.threads.includes(id)))
+                throw Error('write.activation.scope-denied');
+        }
+        const r = (0, memory_migration_1.migrarHandoffs)(carregado, { operadora, escopo });
+        if (args.opcoes.json === true)
+            console.log(JSON.stringify(r, null, 2));
+        else {
+            console.log(`Migracao do tenant ${r.inventario.tenant}: ${r.resultados.filter(i => i.ok).length} confirmados, ${r.falhas} falhas, ${r.inventario.excluidos} excluidos.`);
+            for (const item of r.resultados)
+                console.log(`  ${item.arquivo}: ${item.ok ? item.gravacao?.id : item.erro}`);
+        }
+        return r.ok ? 0 : 1;
+    }
+    if (sub === 'sync' && args.posicionais[2])
+        (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, args.posicionais[2]);
     if (sub === 'status') {
+        const memoria = (0, memoria_1.abrirMemoria)(candidate);
         if (args.opcoes.json === true) {
-            console.log(JSON.stringify(memoria.estado, null, 2));
+            console.log(JSON.stringify({ ...memoria.estado, configSource: memoria.configSource, configDivergent: memoria.configDivergent }, null, 2));
             return 0;
         }
         console.log((0, memoria_1.textoDoEstado)(memoria.estado));
         return 0;
     }
     if (sub === 'sync') {
+        const memoria = (0, memoria_1.abrirMemoria)(carregado);
         const threadId = args.posicionais[2];
         // Thread inexistente reprova aqui, e nao no meio da gravacao.
         if (threadId)
             (0, thread_1.lerThread)(carregado.raiz, threadId);
-        const r = (0, memoria_1.sincronizarMemoria)(carregado, memoria, threadId ?? null);
+        const perfil = (texto(args.opcoes.perfil) ?? 'integral');
+        if (!['fabrica', 'integral'].includes(perfil))
+            throw Error('memory.publication.profile-invalid');
+        if (carregado.manifesto.memory.mode === 'orkmind') {
+            try {
+                const autorizacao = (0, write_activation_1.exigirAtivacao)(carregado, threadId ?? '', 'memory');
+                if (autorizacao.perfil !== 'integral' && perfil !== autorizacao.perfil)
+                    throw Error('write.activation.profile-denied');
+            }
+            catch (error) {
+                const motivo = error instanceof Error
+                    ? /^(?:write\.activation|scope|memory)\.[a-z.-]+/.exec(error.message)?.[0] ?? 'write.activation.invalid'
+                    : 'write.activation.invalid';
+                const detalhe = 'sync nao executado; colisao legada nao foi reavaliada';
+                if (args.opcoes.json === true)
+                    console.log(JSON.stringify({
+                        regime: memoria.regime, estado: memoria.estado, thread: threadId ?? null, perfil,
+                        publicacao: { estado: 'pendente', motivo }, falhas: 1, gravadas: [], erro: motivo, detalhe,
+                    }, null, 2));
+                console.error(`${motivo}: ${detalhe}`);
+                return 1;
+            }
+        }
+        const r = (0, memoria_1.sincronizarMemoria)(carregado, memoria, threadId ?? null, undefined, perfil);
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(r, null, 2));
         }
         else {
             console.log((0, memoria_1.textoDoSync)(r));
         }
-        return 0;
+        return r.estado.pedido === 'orkmind' && r.falhas > 0 ? 1 : 0;
     }
     if (sub === 'search') {
+        const threadId = texto(args.opcoes.thread);
+        if ((args.opcoes.restrito !== undefined || args.opcoes.thread !== undefined ||
+            args.opcoes.janela !== undefined) && !threadId) {
+            throw Error('memory.query.thread-required: use --thread <id>');
+        }
+        const janela = limiteDeLeitura(args.opcoes.janela);
         const tagsBrutas = texto(args.opcoes.tags);
         if (!tagsBrutas) {
             console.error('uso: ork memory search --tags \'{"project":["orkastery"],"skill":["orkastery-decision"]}\'');
@@ -1757,11 +3227,19 @@ function comandoMemory(args) {
         }
         const colecao = texto(args.opcoes.colecao) ?? texto(args.opcoes.collection);
         const limiteBruto = texto(args.opcoes.limite);
+        const limite = threadId ? limiteDeLeitura(args.opcoes.limite) : limiteBruto ? Number(limiteBruto) : undefined;
+        if (threadId)
+            (0, orkmind_1.validarConsultaDelimitada)({ collection: colecao,
+                escopo: (0, orkmind_1.criarEscopoDeLeitura)(carregado.manifesto, threadId), tags,
+                limite: janela ?? orkmind_1.LIMITE_CONSULTA_PADRAO });
+        const memoria = (0, memoria_1.abrirMemoria)(carregado, threadId ? { leituraRestrita: { thread: threadId, limite: janela } } : {});
         const entradas = memoria.buscar({
             collection: colecao,
             tags,
-            limite: limiteBruto ? Number(limiteBruto) : undefined,
+            limite,
         });
+        if (threadId && memoria.regime === 'files')
+            console.error(`memory.query.files: ${memoria.estado.motivo}; resultado nao comprova ausencia na memoria semantica`);
         if (args.opcoes.json === true) {
             console.log(JSON.stringify(entradas, null, 2));
             return 0;
@@ -1785,19 +3263,93 @@ function comandoMemory(args) {
     return 2;
 }
 function main(argv) {
+    // I-35: todo horário para pessoa sai no fuso do dono deste projeto (lido só se for preciso).
+    (0, horario_1.registrarFonteDoFuso)(() => (0, horario_1.fusoDoManifesto)((0, manifest_1.carregarManifesto)()));
+    // Helper fixo do host confiável: o projeto vem da instalação, nunca de toolargs.
+    if (argv[0] === 'receipt-verifiers') {
+        if (argv.length !== 2 || argv[1] !== '--json')
+            throw Error('uso: ork receipt-verifiers --json');
+        const root = process.env.ORK_HITL_ROOT;
+        const privateKey = Object.keys(process.env).some(name => /^ORK_HITL_(?:INGRESS_KEY|NATIVE_KEY)/.test(name));
+        if (root !== undefined || privateKey) {
+            if (!root || !(0, node_path_1.isAbsolute)(root) || fs.realpathSync(root) !== root)
+                throw Error('hitl.receipt.project-unavailable');
+            const carregado = (0, manifest_1.exigirManifesto)(root);
+            if (carregado.raiz !== root)
+                throw Error('hitl.receipt.project-unavailable');
+            for (const id of (0, thread_1.listarIds)(root))
+                (0, hitl_ingress_receipt_1.prepararRecibosParaDespacho)(root, id);
+        }
+        console.log((0, hitl_public_receipt_1.publicHitlVerifiers)() ?? 'null');
+        return 0;
+    }
+    if (argv[0] === 'maestro')
+        return (0, maestro_cli_1.runMaestroCli)(argv.slice(1));
     const args = parseArgs(argv);
     const comando = args.posicionais[0];
+    // `ork --version` tambem chega sem comando: a versao e conferida antes da ajuda.
+    if (args.opcoes.version === true || comando === 'version') {
+        console.log(VERSAO);
+        return 0;
+    }
     if (!comando || args.opcoes.help === true || comando === 'help') {
         console.log(AJUDA);
         return 0;
     }
-    if (args.opcoes.version === true || comando === 'version') {
-        console.log(VERSAO);
-        return 0;
+    const nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)();
+    const ambienteManifesto = (0, manifest_1.carregarManifesto)();
+    if (ambienteManifesto?.manifesto.runtime.provider_policy === 'subscription-only') {
+        // Avaliar ANTES de limpar: um redirecionamento bloqueante não pode desaparecer.
+        const violacoes = (0, policies_1.avaliarPolicies)(ambienteManifesto.manifesto, { gate: 'phase.dispatch' });
+        // O gate oficial precisa observar e registrar a violação (inclusive warn).
+        // Diagnósticos continuam acessíveis; os adapters sanitizam seus filhos sempre.
+        if (violacoes.length === 0)
+            for (const nome of runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO)
+                delete process.env[nome];
     }
     switch (comando) {
+        case 'mcp': {
+            const projeto = texto(args.opcoes.project), host = texto(args.opcoes.host), threadId = texto(args.opcoes.thread);
+            // I-36 (D4): a identidade do despacho so chega com a thread vinculada da sessao filha.
+            const dispatchId = texto(args.opcoes.dispatch);
+            const transporteShip = texto(args.opcoes['ship-transport']) ?? 'github-ssh';
+            const permissoesFilho = texto(args.opcoes['child-permissions']) ?? 'interactive';
+            const permissoesDono = texto(args.opcoes['owner-permissions']);
+            const acao = args.posicionais[1];
+            if (args.posicionais.length !== 2 || !['serve', 'install'].includes(acao) || !projeto ||
+                (host !== 'codex' && host !== 'claude-code') ||
+                Object.keys(args.opcoes).some(k => !['project', 'host', 'ship-transport', 'child-permissions', ...(acao === 'install' ? ['dry-run', 'owner-permissions'] : ['thread', 'dispatch'])].includes(k)) ||
+                (args.opcoes.dispatch !== undefined && (!threadId || !dispatchId || !/^[a-f0-9-]{36}$/.test(dispatchId))) ||
+                argv.filter(a => a === '--ship-transport' || a.startsWith('--ship-transport=')).length > 1 ||
+                argv.filter(a => a === '--child-permissions' || a.startsWith('--child-permissions=')).length > 1 ||
+                (args.opcoes['owner-permissions'] !== undefined && (host !== 'codex' || typeof args.opcoes['owner-permissions'] !== 'string' || !['interactive', 'orchestrate'].includes(permissoesDono ?? ''))) ||
+                argv.filter(a => a === '--owner-permissions' || a.startsWith('--owner-permissions=')).length > 1 ||
+                !['interactive', 'worktree'].includes(permissoesFilho) ||
+                (args.opcoes['child-permissions'] !== undefined && typeof args.opcoes['child-permissions'] !== 'string') ||
+                !['github-ssh', 'bare-local'].includes(transporteShip) ||
+                (args.opcoes['ship-transport'] !== undefined && typeof args.opcoes['ship-transport'] !== 'string') ||
+                (args.opcoes.thread !== undefined && (!threadId || !/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,79}$/.test(threadId))) ||
+                (args.opcoes['dry-run'] !== undefined && args.opcoes['dry-run'] !== true))
+                throw new Error('uso: ork mcp serve|install --project <raiz absoluta> --host codex|claude-code [--ship-transport github-ssh|bare-local] [--child-permissions interactive|worktree] [--owner-permissions interactive|orchestrate somente install Codex] [--dry-run somente install]');
+            if (acao === 'install') {
+                void Promise.resolve().then(() => __importStar(require('./mcp-install'))).then(({ instalarMcp, textoInstalacaoMcp }) => console.log(textoInstalacaoMcp(instalarMcp({ projeto, host, dryRun: args.opcoes['dry-run'] === true, transporteShip: transporteShip, permissoesFilho: permissoesFilho, permissoesDono: permissoesDono }))))
+                    .catch(e => { console.error(`mcp: ${e.message}`); process.exitCode = 1; });
+                return 0;
+            }
+            void Promise.resolve().then(() => __importStar(require('./mcp-server'))).then(({ servirMcp }) => servirMcp({ projeto, host, threadId, dispatchId, nomesProviderHerdados: nomesHerdados, transporteShip: transporteShip, permissoesFilho: permissoesFilho })).catch(e => { console.error(`mcp: ${e.message}`); process.exitCode = 1; });
+            return 0;
+        }
         case 'doctor': {
-            const r = (0, doctor_1.doctor)();
+            if (args.opcoes.modo !== undefined) {
+                const bruto = texto(args.opcoes.modo);
+                if (args.posicionais.length !== 1 || !bruto ||
+                    Object.keys(args.opcoes).some(k => k !== 'modo') || argv.filter(a => a === '--modo' || a.startsWith('--modo=')).length !== 1)
+                    throw Error(`uso: ork doctor --modo ${modos_1.ORDEM_DOS_MODOS.join('|')}`);
+                const r = (0, preflight_1.preflight)(process.cwd(), (0, modos_1.exigirModoVivo)(bruto), nomesHerdados);
+                console.log((0, preflight_1.textoPreflight)(r));
+                return r.prontoPrimeiroBloco ? 0 : 1;
+            }
+            const r = (0, doctor_1.doctor)(process.cwd(), nomesHerdados);
             console.log(r.texto);
             return r.codigo;
         }
@@ -1807,9 +3359,12 @@ function main(argv) {
                 nome: texto(args.opcoes.name) ?? texto(args.opcoes.nome),
                 abbrev: texto(args.opcoes.abbrev),
             });
+            const carregado = (0, manifest_1.exigirManifesto)(r.deteccao.raiz);
+            const agents = (0, agents_md_1.atualizarAgentsMd)(r.deteccao.raiz, carregado.manifesto);
             if (!r.criado) {
                 console.log(`Manifesto ja existe: ${r.caminho}`);
                 console.log('Nada foi sobrescrito. Use --force para regerar.');
+                console.log(`AGENTS.md ${agents.estado}: ${agents.caminho}`);
                 return 0;
             }
             console.log(`Manifesto criado: ${r.caminho}`);
@@ -1817,17 +3372,37 @@ function main(argv) {
             console.log(`  branch base ${r.deteccao.baseBranch}`);
             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}`);
             console.log('');
-            console.log('Proximo passo: ork doctor');
+            console.log(init_2.PROXIMO_PASSO_INIT);
             return 0;
         }
         case 'modos': {
+            // I-43 (T4): `ork modos migrar` tira modo aposentado da CONFIGURACAO do projeto
+            // (`orkastery.yaml` e `setup.json`) e nao toca em historico nenhum. Idempotente:
+            // rodar de novo num projeto ja migrado nao escreve nada.
+            if (args.posicionais[1] === 'migrar') {
+                const carregado = (0, manifest_1.exigirManifesto)();
+                const r = (0, modos_migracao_1.migrarModosAposentados)(carregado.raiz, {
+                    dryRun: args.opcoes['dry-run'] === true,
+                    por: texto(args.opcoes.por),
+                });
+                console.log(args.opcoes.json === true ? JSON.stringify(r, null, 2) : (0, modos_migracao_1.textoDaMigracaoModos)(r));
+                return 0;
+            }
             // `--do-pedido` existe para os adaptadores de host: eles extraem a #TAG do texto do
             // builder SEM reimplementar o parse, e repassam `--mode` ao `ork`. A validacao contra
             // `conduction.allowed_modes` continua sendo do nucleo, no `ork thread new`.
             const pedido = texto(args.opcoes['do-pedido']);
             if (pedido !== undefined) {
                 const carregado = (0, manifest_1.carregarManifesto)();
+                // I-43: `#Look` no pedido nao pode cair no default em silencio. O adaptador
+                // recebe a recusa tipada e saida != 0, e quem escreveu a #TAG fica sabendo.
+                const aposentado = (0, modos_1.extrairTagAposentadaDoPedido)(pedido);
+                if (aposentado) {
+                    console.error((0, modos_1.recusaDeModoAposentado)(aposentado));
+                    return 2;
+                }
                 const extraido = (0, modos_1.extrairTagDoPedido)(pedido);
                 const modo = extraido ?? carregado?.manifesto.conduction.default_mode ?? 'classic';
                 if (args.opcoes.json === true) {
@@ -1847,16 +3422,59 @@ function main(argv) {
             console.log((0, modos_1.tabelaDeModos)());
             return 0;
         }
+        case 'setup':
+            return comandoSetup(args);
+        case 'accounts':
+            return comandoAccounts(args);
+        case 'onboarding':
+            return comandoOnboarding(args);
         case 'thread':
             return comandoThread(args);
+        case 'objective':
+            return comandoObjective(args);
+        case 'creation':
+            return comandoCreation(args);
+        case 'portfolio':
+            return comandoPortfolio(args);
         case 'phase':
             return comandoPhase(args);
+        case 'ledger':
+            return comandoLedger(args);
         case 'sessions':
             return comandoSessions(args);
+        case 'pulse': {
+            if (args.posicionais[1] === 'responder') {
+                // I-41 (GO-FIX 1, B1 e B2): o caminho de volta do resumo. So o ingresso autenticado chama;
+                // argv traz identificadores e o envelope assinado vem por stdin, como no `gate answer`.
+                if (args.opcoes['resposta-stdin'] !== true || args.opcoes.resposta !== undefined || args.posicionais.length !== 2) {
+                    throw new Error('pulse responder exige --resposta-stdin e o envelope do ingresso autenticado');
+                }
+                const carregado = (0, manifest_1.exigirManifesto)();
+                const envelope = (0, hitl_gates_1.lerRespostaStdin)({ por: texto(args.opcoes.por), mensagem: texto(args.opcoes.mensagem),
+                    origem: texto(args.opcoes.origem), canal: texto(args.opcoes.canal), conta: texto(args.opcoes.conta) });
+                const formato = texto(args.opcoes.formato);
+                if (formato !== undefined && formato !== 'telegram' && formato !== 'terminal')
+                    throw new Error('pulse responder: --formato telegram|terminal');
+                console.log(JSON.stringify((0, pulse_resposta_1.responderPeloPulse)(carregado.raiz, envelope, { canal: formato ?? 'telegram' })));
+                return 0;
+            }
+            if (args.posicionais[1] === 'cadencia')
+                return comandoCadenciaDoPulse(args);
+            const p = (0, pulse_1.montarPulse)((0, manifest_1.exigirManifesto)(), { registrar: args.opcoes.registrar === true,
+                escopo: texto(args.opcoes.escopo)?.split(',').map(s => s.trim()),
+                semRuntime: args.opcoes['sem-runtime'] === true,
+                linhasLogs: texto(args.opcoes.linhas) === undefined ? undefined : Number(texto(args.opcoes.linhas)) });
+            console.log(args.opcoes.json === true ? JSON.stringify(p, null, 2) : (0, pulse_1.textoDoPulse)(p));
+            return p.runtime.ok || args.opcoes['sem-runtime'] === true ? 0 : 1;
+        }
         case 'claims':
             return comandoClaims(args);
+        case 'decisao':
+            return comandoDecisao(args);
         case 'verify':
             return comandoVerify(args);
+        case 'ci':
+            return comandoCi(args);
         case 'gate':
             return comandoGate(args);
         case 'retry':
@@ -1867,12 +3485,21 @@ function main(argv) {
             return comandoHandoff(args);
         case 'recall':
             return comandoRecall(args);
+        case 'brain': {
+            const result = (0, company_brain_cli_1.runBrain)((0, manifest_1.exigirManifesto)(), args.posicionais[1] ?? 'status', args.opcoes, args.posicionais.slice(2));
+            console.log(JSON.stringify(result, null, 2));
+            return ['ok', 'empty', 'unknown', 'withheld', 'applied', 'rolled-back'].includes(result.state) ? 0 : 1;
+        }
         case 'memory':
             return comandoMemory(args);
         case 'ship':
             return comandoShip(args);
+        case 'activation':
+            return (0, write_activation_1.comandoAtivacao)((0, manifest_1.exigirManifesto)(), args);
         case 'lease':
             return comandoLease(args);
+        case 'conducao':
+            return comandoConducao(args);
         case 'board':
             return comandoBoard(args);
         case 'orquestracao':
@@ -1890,6 +3517,19 @@ function main(argv) {
             return comandoAdapter(args);
         case 'prompt':
             return comandoPrompt(args);
+        case 'docs':
+            return comandoDocs(args);
+        case 'roadmap':
+            return comandoRoadmap(args);
+        case 'demo': {
+            // I-56 (RM-046): a promessa em trinta segundos, offline, sem runtime e sem tocar o projeto.
+            const r = (0, demo_1.executarDemo)({ dir: texto(args.opcoes.dir), manter: args.opcoes.manter === true, escrever: (l) => console.log(l) });
+            return r.ok ? 0 : 1;
+        }
+        case 'fabrica':
+            return comandoFabrica(args);
+        case 'licoes':
+            return comandoLicoes(args);
         case 'ciclos':
             console.log((0, ciclos_1.tabelaDeVariantes)());
             return 0;
@@ -1904,7 +3544,14 @@ if (require.main === module) {
         process.exitCode = main(process.argv.slice(2));
     }
     catch (e) {
-        console.error(`erro: ${e.message}`);
-        process.exitCode = 1;
+        // I-36 (T12): a recusa de conducao e resposta, nao erro: o texto para o humano, ou o JSON.
+        if (e instanceof conducao_1.ErroDeConducao) {
+            console.log(process.argv.includes('--json') ? JSON.stringify(e.recusa, null, 2) : e.recusa.texto);
+            process.exitCode = 3;
+        }
+        else {
+            console.error(`erro: ${e.message}`);
+            process.exitCode = 1;
+        }
     }
 }