@orkastery/cli 0.2.0

package/dist/index.js

@@ -0,0 +1,1910 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * `ork`: nucleo CLI deterministico do Orkastery (bloco B0).
+ *
+ * Sem LLM embutido: o `ork` monta prompt, despacha pelo runtime adapter, verifica no
+ * 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 auditoria_1 = require("./auditoria");
+const auditrun_1 = require("./auditrun");
+const superficie_1 = require("./superficie");
+const board_1 = require("./board");
+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 evalrunner_1 = require("./evalrunner");
+const gates_1 = require("./gates");
+const handoff_1 = require("./handoff");
+const hosts_1 = require("./hosts");
+const init_1 = require("./init");
+const leases_1 = require("./leases");
+const master_1 = require("./master");
+const manifest_1 = require("./manifest");
+const memoria_1 = require("./memoria");
+const recall_1 = require("./recall");
+const fix_1 = require("./fix");
+const ratelimit_1 = require("./ratelimit");
+const retry_1 = require("./retry");
+const modos_1 = require("./modos");
+const phase_1 = require("./phase");
+const prompts_1 = require("./prompts");
+const sessoes_1 = require("./sessoes");
+const util_1 = require("./util");
+const ship_1 = require("./ship");
+const thread_1 = require("./thread");
+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';
+/** Parse simples de argumentos: `--chave valor`, `--chave=valor` e flags booleanas. */
+function parseArgs(argv) {
+    const posicionais = [];
+    const opcoes = {};
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a.startsWith('--')) {
+            const igual = a.indexOf('=');
+            if (igual > 0) {
+                opcoes[a.slice(2, igual)] = a.slice(igual + 1);
+            }
+            else {
+                const proximo = argv[i + 1];
+                if (proximo !== undefined && !proximo.startsWith('--')) {
+                    opcoes[a.slice(2)] = proximo;
+                    i++;
+                }
+                else {
+                    opcoes[a.slice(2)] = true;
+                }
+            }
+        }
+        else {
+            posicionais.push(a);
+        }
+    }
+    return { posicionais, opcoes };
+}
+function texto(v) {
+    return typeof v === 'string' ? v : undefined;
+}
+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
+
+  thread new <nome> --modo <MODO>           Cria a thread, o slug de 3 partes e o ledger
+        [--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
+
+  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
+                                             efetivo vai ao ledger como fato verificavel)
+  phase list <thread-id>                    Historico do ledger da thread
+                                            (mostra o modelo/esforco reais de cada fase)
+
+  sessions [--all]                          Sessoes vivas do runtime, cruzadas com as threads
+  sessions logs <sessao> [--linhas N]       Logs de uma sessao
+  sessions stop <sessao>                    Para uma sessao
+  sessions attach <sessao>                  Imprime o comando de attach (precisa de TTY)
+
+  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
+  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)
+  verify <thread-id> [--baseline]           Reexecuta claims e verify do manifesto no HEAD real
+        [--so-claims]                       --baseline grava o estado do mundo antes do GO
+
+  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
+
+  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
+        [--fase F] [--json]                      (calcula, nao executa, nao gasta tentativa)
+  retry run <thread-id> [--reverify]        Executa a acao tipada do ultimo gate reprovado
+        [--por Q] [--dry-run]                    (--por autoriza quando o bloco do modo pausa)
+  retry list [--json]                       Fila DURAVEL de rate limit do projeto
+  retry resume [--id R1] [--agora ISO]      Retoma a fase morta por rate limit na janela seguinte
+        [--ocupacao 0..1] [--forcar] [--dry-run] (playbooks: mesma-sessao, nova-sessao, escalada)
+  retry cancel <id> --motivo M              Tira um pedido da fila, com motivo registrado
+  retry parse --stderr "<texto>"            Le o horario de reset do stderr do adapter
+
+  fix open <thread-id> [--so-claims]        GO-FIX: deriva a spec exata do CHECK reprovado
+        [--reverify] [--json]                    (uma correcao por motivo tipado, tipo A ou B)
+  fix list <thread-id> [--rodada N]         Correcoes da rodada e o veredito de cada uma
+  fix reverify <thread-id> [--rodada N]     CHECK-REVERIFY com veredito POR correcao
+        [--parcial] [--json]                     (--parcial e RECUSADO se houver tipo B)
+
+  handoff export <thread-id>                Handoff triado CRITICO/IMPORTANTE/RESUMIVEL
+        [--proxima-fase FASE] [--slug S]
+  handoff recall <thread-id> <ponteiro>     Resolve um ponteiro path#ancora de volta ao conteudo
+
+  recall <thread-id> --fase FASE            Recuperacao TARDIA: resolve so os ponteiros do
+        [--id ptr-N] [--todos] [--forcar]        momento (retrieve_when), nunca a janela inteira
+        [--sem-conteudo] [--json]                (orkmind por tag, files por path#ancora)
+
+  memory status [--json]                    Regime efetivo (files|orkmind), tenant e degradacao
+  memory sync [<thread-id>] [--json]        Publica decisoes, policies, handoff, licao e roadmap
+  memory search --tags '<json>' [--colecao C]  Busca deterministica por tag (mandatory sempre volta)
+        [--limite N] [--json]
+
+  ship <thread-id> --para <branch>          Merge --no-ff serializado por lease e push PROVADO
+        [--de <branch>] [--remoto origin] [--autorizar-push <quem>] [--sem-push] [--dry-run]
+
+  board [--all]                             Visao unica das threads (todos os perfis com --all)
+  board plan                                Escalonador: quem avanca agora, quem espera e por que
+
+  orquestracao status [--all] [--json]      Monitor PROATIVO de pausas e impedimentos: quem esta
+        [--atencao N] [--so-paradas]             parado, esperando o que, ha quanto tempo e o que
+        [--sem-runtime] [--exigir-limpo]         destrava (alias curto: ork monitor)
+
+  worktree ensure <thread-id>               Garante a worktree da thread (base resolvida pelo ork)
+  worktree sync <thread-id> [--dry-run]     Rebasa a branch da thread quando a base avancou
+  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
+
+  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]
+
+  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 classes                            As classes de falha fixas do POSTMORTEM
+
+  ciclos                                    Variantes de ciclo de "ork thread new --ciclo"
+  modos --do-pedido "<texto>" [--json]      Le a #TAG do pedido do builder (usado pelos adaptadores)
+
+  prompt list                               Templates de prompt (embutidos e os do projeto)
+  prompt lint [--template ID]               Reprova template quebrado antes de ele virar despacho
+  prompt render <thread-id> --fase F        Mostra o prompt exato, com o sha256 que vai ao ledger
+        [--pedido "<texto>"] [--template ID]
+  prompt render --exemplo --fase F --modo M Renderiza sem thread nenhuma, para revisar o texto
+
+  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]
+
+  eval [--skill S] [--canario C]            Canarios de comportamento + corpus das skills finas
+        [--so-canarios] [--so-skills] [--json]   (sai != 0 em qualquer falha)
+
+  audit packs [--estagio E] [--pack P]      Os 7 packs, o estagio que os ativa e a postura
+  audit run <pack> [--profile P]            Monta o prompt do pack e despacha pelo runtime adapter
+        [--since Nd] [--tudo] [--effort E] [--model M] [--agora "<quem>"] [--forcar] [--dry-run]
+  audit list                                Rodadas de auditoria do projeto
+  audit show <rodada> [--ledger]            Contexto, achados e propostas de uma rodada
+  audit prompt <pack> [--since Nd]          O prompt exato do pack, com o sha256 que vai ao ledger
+  audit lint                                Reprova template de auditoria quebrado (auditors/)
+  audit ingest <rodada> --arquivo J         Registra em lote os achados que o auditor escreveu
+  audit finding add <rodada> --regra R      Registra um achado com evidencia, claim e proposta
+        --titulo T --arquivo caminho:linha --impacto I --fix F --estimativa E
+        [--severidade critico|maior|menor] [--irreversivel "<passo>"] [--verificar "<comando>"]
+  audit verify <rodada>                     Reexecuta as claims dos achados (auditor sem self-report)
+  audit report <rodada> [--publicar]        Relatorio com o bloco OBRIGATORIO de propostas
+  audit divida [--pack P] [--todos]         Board de divida: propostas abertas e recorrencia
+  audit surface [<dir>] [--regra SPn]       Varredura DETERMINISTICA da superficie de ataque de rede
+        [--limite N] [--json]                    (SP8..SP12; sai != 0 quando ha achado)
+  audit surface --registrar <rodada>        Grava os achados da varredura no board da rodada
+  audit finding estado <id> <estado>        Carimba o achado (aberto|adiado|resolvido|descartado)
+
+  thread new <nome> --from-finding <ID>     Abre a thread a partir de um achado de auditoria
+        [--modo M] [--worktree auto] [--dry-run]   (evidencia, claim e proposta viajam junto)
+
+Regimes de memoria: files (fallback honesto) e orkmind (bloco B6, base propria por tenant
+declarada em memory.database_url_env pelo NOME da variavel de ambiente, sem fallback).
+Colecoes gravadas no OrkMind: decision, handoff, rule, learning, roadmap (source=agent,
+nunca mandatory: regra critica so nasce de humano autenticado).
+
+Retry tipado (bloco B3): reexecutar, corrigir-dirigido, sincronizar-worktree,
+escalar-esforco, esperar-janela, escalar-humano, sem-retry. Violacao de custo
+(cost.violation) NUNCA recebe retry automatico. O limite de escalacao do manifesto
+(retry.max_tentativas) pausa QUALQUER modo, inclusive #Auto.
+
+Monitor de orquestracao (ork orquestracao status / ork monitor): duas naturezas de parada.
+pausa-humana e a parada PREVISTA pelo modo (o bloco fechou e espera veredito, com o
+pausaSobre do bloco dizendo o que o humano decide); impedimento e a nao prevista
+(lease.busy, runtime.rate-limited, concurrency.limite e os demais gates tipados). Tudo e
+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.
+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,
+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
+administracao exposto, rota sem rate limit, CORS permissivo, rota sem esquema de payload.
+Estagios do produto: nascente, crescendo, maduro (hardening gradual, visao secao 5.2).
+`;
+function comandoThread(args) {
+    const sub = args.posicionais[1];
+    if (sub === 'new') {
+        const carregado = (0, manifest_1.exigirManifesto)();
+        // `--from-finding <id>`: o achado de auditoria vira thread sem retrabalho (bloco B5).
+        // O nome posicional passa a ser opcional, porque o titulo do achado ja serve de nome.
+        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;
+            }
+            const brutoWorktreeAchado = args.opcoes.worktree;
+            const criarWorktreeAchado = brutoWorktreeAchado === true || brutoWorktreeAchado === 'auto';
+            const r = (0, auditrun_1.abrirThreadDoAchado)(carregado, doAchado, {
+                nome: args.posicionais[2],
+                modo: modoAchado ?? undefined,
+                slug: texto(args.opcoes.slug),
+                assunto: texto(args.opcoes.assunto),
+                criarWorktree: criarWorktreeAchado,
+                worktree: criarWorktreeAchado ? null : (texto(brutoWorktreeAchado) ?? null),
+                dryRun: args.opcoes['dry-run'] === true,
+            });
+            if (!r.ok) {
+                console.error(`Thread a partir do achado ${r.achado.id} RECUSADA.`);
+                console.error(`  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[r.motivo ?? 'claims.failed']}`);
+                console.error(`  motivo tipado: ${r.motivo}`);
+                console.error(`  detalhe: ${r.detalhe}`);
+                console.error(`  correcao: ${r.correcao}`);
+                return 1;
+            }
+            const gravadaDoAchado = args.opcoes['dry-run'] !== true;
+            console.log(gravadaDoAchado
+                ? `Thread criada a partir do achado ${r.achado.id}.`
+                : 'Simulacao (--dry-run), nada foi gravado.');
+            console.log((0, divida_1.textoDoAchado)(r.achado));
+            console.log('');
+            if (r.thread) {
+                console.log((0, thread_1.resumoDaThread)(r.thread));
+                console.log('');
+                console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(r.thread.slug)}`);
+            }
+            if (r.motivo === 'claims.unverifiable') {
+                console.log('');
+                console.log(`  ${r.detalhe}`);
+            }
+            // Bloco B6: a origem da thread vai para a colecao `roadmap` (achado -> proposta ->
+            // thread -> entrega e rastreavel sem abrir o board).
+            if (r.thread && gravadaDoAchado) {
+                relatarPublicacao((0, memoria_1.publicar)(carregado, r.thread.id, {
+                    tipo: 'achado',
+                    referencia: r.achado.id,
+                    detalhe: `Achado ${r.achado.id} (${r.achado.pack}/${r.achado.regra}): ${r.achado.titulo}. ` +
+                        `Fix proposto: ${r.achado.proposta.fix}`,
+                }));
+            }
+            if (gravadaDoAchado && r.thread) {
+                console.log(`  origem do GOAL: .orkastery/threads/${r.thread.id}/achado.json`);
+                console.log('');
+                console.log('Pedido de GOAL ja montado a partir do achado:');
+                console.log('');
+                console.log(r.pedido);
+                console.log('');
+                console.log('Proximo passo:');
+                console.log(`  ork phase run ${r.thread.id} GOAL --prompt "$(cat .orkastery/threads/${r.thread.id}/pedido-goal.md)"`);
+            }
+            return 0;
+        }
+        const nome = args.posicionais[2];
+        if (!nome) {
+            console.error('uso: ork thread new <nome> --modo <MODO>');
+            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(', ')}`);
+            return 2;
+        }
+        const dryRun = args.opcoes['dry-run'] === true;
+        const brutoWorktree = args.opcoes.worktree;
+        // `--worktree auto` (ou `--worktree` sozinho) cria a worktree isolada da thread;
+        // um caminho reusa um diretorio que ja existe.
+        const criarWorktree = brutoWorktree === true || brutoWorktree === 'auto';
+        const brutoCiclo = texto(args.opcoes.ciclo) ?? texto(args.opcoes.variante);
+        const variante = brutoCiclo ? (0, ciclos_1.parseVariante)(brutoCiclo) : null;
+        if (brutoCiclo && !variante) {
+            console.error(`variante de ciclo invalida: "${brutoCiclo}". Use uma de: ${Object.keys(ciclos_1.VARIANTES).join(', ')}`);
+            return 2;
+        }
+        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,
+        });
+        console.log(gravada ? 'Thread criada.' : 'Simulacao (--dry-run), nada foi gravado.');
+        console.log((0, thread_1.resumoDaThread)(thread));
+        console.log('');
+        console.log(`  slug em 3 partes: ${(0, phase_1.descreverSlug)(thread.slug)}`);
+        if (gravada) {
+            console.log(`  estado: .orkastery/threads/${thread.id}/thread.json`);
+            // Bloco B6: a origem da thread e as policies do projeto vao para a memoria
+            // semantica quando ela esta ligada. Em regime files nada muda nesta saida.
+            relatarPublicacao((0, memoria_1.publicar)(carregado, thread.id));
+            console.log('');
+            console.log(`Proximo passo: ork phase run ${thread.id} ${thread.faseAtual} --prompt "<pedido>"`);
+        }
+        return 0;
+    }
+    if (sub === 'list' || sub === undefined) {
+        const carregado = (0, manifest_1.exigirManifesto)();
+        console.log((0, thread_1.tabelaDeThreads)(carregado.raiz));
+        return 0;
+    }
+    if (sub === 'status') {
+        const carregado = (0, manifest_1.exigirManifesto)();
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork thread status <thread-id>');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        console.log(`Thread ${thread.id}`);
+        console.log((0, thread_1.resumoDaThread)(thread));
+        console.log('');
+        if (thread.sessoes.length === 0) {
+            console.log('  nenhuma sessao despachada ainda');
+        }
+        else {
+            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'}`);
+            }
+        }
+        console.log('');
+        console.log(`  pausas humanas do modo: ${(0, modos_1.pausasDoModo)(thread.modo)}`);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: thread ${sub}`);
+    return 2;
+}
+function comandoPhase(args) {
+    const sub = args.posicionais[1];
+    const carregado = (0, manifest_1.exigirManifesto)();
+    if (sub === 'run') {
+        const id = args.posicionais[2];
+        const faseBruta = args.posicionais[3];
+        const prompt = texto(args.opcoes.prompt);
+        if (!id || !faseBruta || !prompt) {
+            console.error('uso: ork phase run <thread-id> <FASE> --prompt "<texto>"');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        const fase = (0, thread_1.exigirFase)(thread, faseBruta);
+        const r = (0, phase_1.rodarFase)(carregado, id, {
+            fase,
+            prompt,
+            model: texto(args.opcoes.model),
+            effort: texto(args.opcoes.effort),
+            dryRun: args.opcoes['dry-run'] === true,
+        });
+        if (r.dryRun) {
+            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(`  modelo/esforco : ${r.model}/${r.effort}`);
+            console.log(`  comando        : claude --bg "<prompt>" --name ${r.slug} ...`);
+            return 0;
+        }
+        if (r.bloqueado) {
+            console.error(`Despacho BLOQUEADO pelo gate tipado: ${r.motivo}`);
+            for (const v of r.violacoes) {
+                console.error(`  [${v.severidade}] policy ${v.policy}: ${v.detalhe}`);
+                console.error(`           correcao: ${v.correcao}`);
+            }
+            console.error(`  o prompt nao foi gravado em disco; evento gate_blocked no ledger de ${id}`);
+            return 1;
+        }
+        if (!r.sessionId) {
+            console.error(`Despacho falhou: ${r.erro}`);
+            console.error(`  evento registrado no ledger de ${id}`);
+            return 1;
+        }
+        console.log(`Fase ${fase} despachada como background agent.`);
+        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(`  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}`);
+        return r.verificada ? 0 : 1;
+    }
+    if (sub === 'list') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork phase list <thread-id>');
+            return 2;
+        }
+        console.log((0, phase_1.tabelaDoLedger)(carregado.raiz, id));
+        return 0;
+    }
+    console.error(`subcomando desconhecido: phase ${sub}`);
+    return 2;
+}
+function comandoSessions(args) {
+    const sub = args.posicionais[1];
+    const carregado = (0, manifest_1.carregarManifesto)();
+    const raiz = carregado?.raiz ?? process.cwd();
+    if (sub === undefined || sub === 'list') {
+        console.log((0, sessoes_1.tabelaDeSessoes)(raiz, args.opcoes.all === true));
+        return 0;
+    }
+    const chave = args.posicionais[2];
+    if (!chave) {
+        console.error(`uso: ork sessions ${sub} <sessao>`);
+        return 2;
+    }
+    if (sub === 'logs') {
+        const n = Number(texto(args.opcoes.linhas) ?? '60');
+        const r = (0, sessoes_1.logsDaSessao)(chave, Number.isFinite(n) ? n : 60);
+        console.log(r.texto);
+        return r.codigo;
+    }
+    if (sub === 'stop') {
+        const r = (0, sessoes_1.pararSessao)(chave);
+        console.log(r.texto);
+        return r.codigo;
+    }
+    if (sub === 'attach') {
+        const r = (0, sessoes_1.comandoDeAttach)(chave);
+        console.log(r.texto);
+        return r.codigo;
+    }
+    console.error(`subcomando desconhecido: sessions ${sub}`);
+    return 2;
+}
+function comandoClaims(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    if (sub === 'add') {
+        const id = args.posicionais[2];
+        const arquivo = args.posicionais[3];
+        const alegacao = texto(args.opcoes.claim) ?? texto(args.opcoes.alegacao);
+        if (!id || !arquivo || !alegacao) {
+            console.error('uso: ork claims add <thread-id> <arquivo> --claim "<alegacao>" [--verificar "<comando>"]');
+            return 2;
+        }
+        const comando = texto(args.opcoes.verificar) ?? texto(args.opcoes.verify);
+        const faseBruta = texto(args.opcoes.fase);
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        const claim = (0, claims_1.adicionarClaim)(carregado.raiz, id, {
+            arquivo,
+            alegacao,
+            verificar: comando ? [comando] : [],
+            fase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
+        });
+        console.log(`Claim ${claim.id} registrada na thread ${id}.`);
+        console.log(`  arquivo    ${claim.arquivo}`);
+        console.log(`  alegacao   ${claim.alegacao}`);
+        console.log(`  negativa   ${claim.negativa ? 'sim (exige comando de verificacao)' : 'nao'}`);
+        console.log(`  verificar  ${claim.verificar.join(' && ') || '(nenhum comando declarado)'}`);
+        console.log(`  estado     ${claim.estado}`);
+        if (claim.negativa && claim.verificar.length === 0) {
+            console.log('');
+            console.log('AVISO: alegacao negativa sem comando de verificacao reprova em `ork verify`.');
+        }
+        return 0;
+    }
+    if (sub === 'verificar') {
+        const id = args.posicionais[2];
+        const claimId = args.posicionais[3];
+        const comando = texto(args.opcoes.comando) ?? texto(args.opcoes.verificar);
+        if (!id || !claimId || !comando) {
+            console.error('uso: ork claims verificar <thread-id> <claim-id> --comando "<comando>"');
+            return 2;
+        }
+        const claim = (0, claims_1.anexarComando)(carregado.raiz, id, claimId, comando);
+        console.log(`Claim ${claim.id} agora tem comando de verificacao.`);
+        console.log(`  verificar  ${claim.verificar.join(' && ')}`);
+        console.log(`  estado     ${claim.estado}`);
+        console.log('');
+        console.log(`Prove agora: ork verify ${id}`);
+        return 0;
+    }
+    if (sub === 'retirar') {
+        const id = args.posicionais[2];
+        const claimId = args.posicionais[3];
+        const motivo = texto(args.opcoes.motivo);
+        if (!id || !claimId || !motivo) {
+            console.error('uso: ork claims retirar <thread-id> <claim-id> --motivo "<motivo>"');
+            return 2;
+        }
+        const claim = (0, claims_1.retirarClaim)(carregado.raiz, id, claimId, motivo);
+        console.log(`Claim ${claim.id} retirada da thread ${id}.`);
+        console.log(`  alegacao   ${claim.alegacao}`);
+        console.log(`  motivo     ${motivo}`);
+        console.log('  o historico da alegacao continua no claims.jsonl e no ledger.');
+        return 0;
+    }
+    if (sub === 'list' || sub === undefined) {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork claims list <thread-id>');
+            return 2;
+        }
+        console.log((0, claims_1.tabelaDeClaims)(carregado.raiz, id));
+        return 0;
+    }
+    console.error(`subcomando desconhecido: claims ${sub}`);
+    return 2;
+}
+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]');
+        return 2;
+    }
+    if (args.opcoes.baseline === true) {
+        const b = (0, verify_1.gravarBaseline)(carregado, id);
+        console.log(`Baseline gravada para a thread ${id}.`);
+        console.log(`  commit ${b.commit}`);
+        for (const c of b.comandos) {
+            console.log(`  ${c.nome.padEnd(10)} ${c.ok ? 'passava' : `ja falhava (codigo ${c.code})`}  ${c.comando}`);
+        }
+        if (b.comandos.length === 0) {
+            console.log('  (nenhum comando em verify: no manifesto; sem baseline nao ha como separar regressao)');
+        }
+        return 0;
+    }
+    const r = (0, verify_1.verificar)(carregado, id, { soClaims: args.opcoes['so-claims'] === true });
+    console.log((0, verify_1.textoDoVerify)(r));
+    return r.ok ? 0 : 1;
+}
+function comandoGate(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    if (sub === 'next') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork gate next <thread-id> [--proximo FASE] [--ocupacao 0..1]');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        const proximoBruto = texto(args.opcoes.proximo) ?? texto(args.opcoes['proxima-fase']);
+        const ocupacaoBruta = texto(args.opcoes.ocupacao);
+        const janelaBruta = texto(args.opcoes.janela);
+        const v = (0, tokens_1.gateDeTokens)(carregado, id, {
+            proximo: proximoBruto ? (0, thread_1.exigirFase)(thread, proximoBruto) : undefined,
+            ocupacao: ocupacaoBruta !== undefined ? Number(ocupacaoBruta) : undefined,
+            fonte: texto(args.opcoes.fonte),
+            transcript: texto(args.opcoes.transcript),
+            janela: janelaBruta !== undefined ? Number(janelaBruta) : undefined,
+            refazer: args.opcoes.refazer === true,
+            sessao: texto(args.opcoes.sessao),
+        });
+        console.log((0, tokens_1.textoDoGateDeTokens)(v));
+        return 0;
+    }
+    if (sub === 'approve') {
+        const id = args.posicionais[2];
+        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>');
+            return 2;
+        }
+        (0, thread_1.lerThread)(carregado.raiz, id);
+        const e = (0, gates_1.aprovarGateHumano)(carregado.raiz, id, sobre, por, texto(args.opcoes.obs));
+        console.log(`Autorizacao humana registrada no ledger da thread ${id}.`);
+        console.log(`  sobre          ${sobre}`);
+        console.log(`  autorizado por ${por}`);
+        console.log(`  quando         ${e.ts}`);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: gate ${sub}`);
+    return 2;
+}
+/**
+ * `ork retry`: a politica de retry tipada e a fila duravel de rate limit (bloco B3).
+ *
+ * O comando existe separado do `ork gate` porque ele nao decide VERDADE: ele decide o
+ * que fazer com uma verdade que o gate ja estabeleceu. `plan` calcula sem executar, e
+ * por isso nao gasta tentativa nem toca no repositorio.
+ */
+function comandoRetry(args) {
+    const sub = args.posicionais[1];
+    if (sub === 'policy') {
+        const alvo = texto(args.opcoes.motivo);
+        if (alvo) {
+            const politica = retry_1.POLITICA_DE_RETRY[alvo];
+            if (!politica) {
+                console.error(`motivo tipado desconhecido: ${alvo}`);
+                console.error(`  conhecidos: ${Object.keys(retry_1.POLITICA_DE_RETRY).join(', ')}`);
+                return 2;
+            }
+            if (args.opcoes.json === true) {
+                console.log(JSON.stringify(politica, null, 2));
+                return 0;
+            }
+            console.log(`motivo tipado: ${politica.motivo}`);
+            console.log(`  significado  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[politica.motivo]}`);
+            console.log(`  acao         ${politica.acao}`);
+            console.log(`  automatica   ${politica.automatica ? 'sim' : 'nao'}`);
+            console.log(`  por que      ${politica.porque}`);
+            console.log(`  correcao     ${politica.correcao}`);
+            return 0;
+        }
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(Object.values(retry_1.POLITICA_DE_RETRY), null, 2));
+            return 0;
+        }
+        console.log('Politica de retry por motivo tipado de gate (bloco B3)');
+        console.log('');
+        console.log((0, retry_1.tabelaDaPolitica)());
+        console.log('');
+        console.log('A politica e a MESMA em todos os modos: o modo afrouxa a pausa, nunca a');
+        console.log('verificacao. cost.violation nunca recebe retry automatico, e o limite de');
+        console.log('escalacao (retry.max_tentativas) pausa qualquer modo, inclusive #Auto.');
+        return 0;
+    }
+    if (sub === 'parse') {
+        const bruto = texto(args.opcoes.stderr) ?? args.posicionais.slice(2).join(' ');
+        if (!bruto) {
+            console.error('uso: ork retry parse --stderr "<texto do stderr do adapter>"');
+            return 2;
+        }
+        const sinal = (0, ratelimit_1.parseRateLimit)(bruto);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(sinal, null, 2));
+            return sinal ? 0 : 1;
+        }
+        if (!sinal) {
+            console.log('Nenhum sinal de rate limit reconhecido neste texto.');
+            return 1;
+        }
+        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(`  trecho         ${sinal.trecho}`);
+        if (sinal.resetEm === null) {
+            console.log('');
+            console.log('  Sem hora no texto, a fila usa retry.janela_padrao_min do manifesto e marca');
+            console.log('  o pedido como janela ESTIMADA. O `ork` nao inventa horario de reset.');
+        }
+        return 0;
+    }
+    const carregado = (0, manifest_1.exigirManifesto)();
+    if (sub === 'plan' || sub === 'run') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error(`uso: ork retry ${sub} <thread-id> [--motivo M] [--fase F]`);
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        const faseBruta = texto(args.opcoes.fase);
+        const opcoes = {
+            motivo: texto(args.opcoes.motivo),
+            fase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
+            autorizadoPor: texto(args.opcoes.por) ?? texto(args.opcoes.quem),
+        };
+        if (sub === 'plan') {
+            const plano = (0, retry_1.planejarRetry)(carregado, id, opcoes);
+            if (args.opcoes.json === true) {
+                console.log(JSON.stringify(plano, null, 2));
+                return 0;
+            }
+            console.log((0, retry_1.textoDoPlano)(plano));
+            return 0;
+        }
+        const r = (0, retry_1.executarRetry)(carregado, id, {
+            ...opcoes,
+            dryRun: args.opcoes['dry-run'] === true,
+            reverify: args.opcoes.reverify === true,
+        });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(r, null, 2));
+        }
+        else {
+            console.log((0, retry_1.textoDoRetry)(r));
+        }
+        // Codigo de saida != 0 quando nada pode ser feito sozinho: e o sinal para o
+        // orquestrador parar e chamar o humano, em vez de seguir achando que retomou.
+        return r.executada ? 0 : 1;
+    }
+    if (sub === 'list') {
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify((0, ratelimit_1.lerFilaDeRetomada)(carregado.raiz), null, 2));
+            return 0;
+        }
+        console.log((0, ratelimit_1.tabelaDaFila)(carregado.raiz));
+        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('Retome com: ork retry resume');
+        }
+        return 0;
+    }
+    if (sub === 'resume') {
+        const ocupacaoBruta = texto(args.opcoes.ocupacao);
+        const opcoes = {
+            quando: texto(args.opcoes.agora),
+            dryRun: args.opcoes['dry-run'] === true,
+            forcar: args.opcoes.forcar === true,
+            ocupacao: ocupacaoBruta !== undefined ? Number(ocupacaoBruta) : undefined,
+            fonte: texto(args.opcoes.fonte),
+        };
+        const idPedido = texto(args.opcoes.id);
+        const rs = idPedido
+            ? [(0, retry_1.retomarPorId)(carregado, idPedido, opcoes)]
+            : (0, retry_1.retomarFila)(carregado, opcoes);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(rs, null, 2));
+        }
+        else {
+            console.log((0, retry_1.textoDaRetomada)(rs));
+        }
+        // Escalada nao e sucesso: ela e o pedido de socorro que pausa qualquer modo.
+        return rs.some((r) => r.playbook === 'escalada') ? 1 : 0;
+    }
+    if (sub === 'cancel') {
+        const idPedido = args.posicionais[2];
+        const motivo = texto(args.opcoes.motivo);
+        if (!idPedido || !motivo) {
+            console.error('uso: ork retry cancel <id> --motivo "<motivo>"');
+            return 2;
+        }
+        const p = (0, retry_1.cancelarPedido)(carregado, idPedido, motivo);
+        console.log(`Pedido ${p.id} cancelado na fila de rate limit.`);
+        console.log(`  thread   ${p.thread}`);
+        console.log(`  fase     ${p.fase}`);
+        console.log(`  motivo   ${motivo}`);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: retry ${sub ?? ''}`);
+    return 2;
+}
+/**
+ * `ork fix`: o sub-loop GO-FIX / CHECK-REVERIFY (bloco B3).
+ *
+ * `open` deriva a spec do resultado REAL do `ork verify`; `reverify` da veredito POR
+ * correcao. O `--parcial` e recusado quando a rodada tem correcao tipo B, porque
+ * parcial depois de tipo B nao e CHECK (DoD 10).
+ */
+function comandoFix(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    const id = args.posicionais[2];
+    if (sub === 'open') {
+        if (!id) {
+            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 reverify = args.opcoes.reverify === true && rodada.correcoes.length > 0
+            ? (0, fix_1.reverificar)(carregado, id, { rodada: rodada.rodada })
+            : null;
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify({ rodada, reverify }, null, 2));
+        }
+        else {
+            console.log((0, fix_1.textoDaRodada)(rodada));
+            if (reverify) {
+                console.log('');
+                console.log((0, fix_1.textoDoReverify)(reverify));
+            }
+        }
+        if (rodada.correcoes.length === 0)
+            return 0;
+        return reverify && reverify.veredito === 'PASSOU' ? 0 : 1;
+    }
+    if (sub === 'list') {
+        if (!id) {
+            console.error('uso: ork fix list <thread-id> [--rodada N]');
+            return 2;
+        }
+        (0, thread_1.lerThread)(carregado.raiz, id);
+        const rodadaBruta = texto(args.opcoes.rodada);
+        const rodada = rodadaBruta ? Number(rodadaBruta) : (0, fix_1.ultimaRodada)(carregado.raiz, id);
+        if (rodada === 0) {
+            console.log(`A thread ${id} nao tem rodada de GO-FIX. Abra com: ork fix open ${id}`);
+            return 0;
+        }
+        const correcoes = (0, fix_1.correcoesDaRodada)(carregado.raiz, id, rodada);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(correcoes, null, 2));
+            return 0;
+        }
+        console.log(`Correcoes da rodada ${rodada} da thread ${id}`);
+        console.log('');
+        console.log((0, util_1.tabela)(['ID', 'TIPO', 'MOTIVO', 'ALVO', 'ESTADO', 'JULGADO POR'], correcoes.map((c) => [
+            c.id,
+            c.tipo,
+            c.origem,
+            c.alvo,
+            c.estado,
+            c.verificar.join(' && ') || '(verify completo)',
+        ])));
+        return 0;
+    }
+    if (sub === 'reverify') {
+        if (!id) {
+            console.error('uso: ork fix reverify <thread-id> [--rodada N] [--parcial]');
+            return 2;
+        }
+        const rodadaBruta = texto(args.opcoes.rodada);
+        const r = (0, fix_1.reverificar)(carregado, id, {
+            rodada: rodadaBruta ? Number(rodadaBruta) : undefined,
+            parcial: args.opcoes.parcial === true,
+        });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(r, null, 2));
+        }
+        else {
+            console.log((0, fix_1.textoDoReverify)(r));
+        }
+        return r.veredito === 'PASSOU' ? 0 : 1;
+    }
+    console.error(`subcomando desconhecido: fix ${sub ?? ''}`);
+    return 2;
+}
+function comandoHandoff(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    const id = args.posicionais[2];
+    if (sub === 'export') {
+        if (!id) {
+            console.error('uso: ork handoff export <thread-id> [--proxima-fase FASE]');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(carregado.raiz, id);
+        const faseBruta = texto(args.opcoes['proxima-fase']) ?? texto(args.opcoes.fase);
+        const r = (0, handoff_1.exportarHandoff)(carregado, id, {
+            proximaFase: faseBruta ? (0, thread_1.exigirFase)(thread, faseBruta) : undefined,
+            slugDestino: texto(args.opcoes.slug),
+        });
+        console.log((0, handoff_1.textoDoHandoff)(r.handoff, r.caminho));
+        console.log('');
+        console.log(`Historico: ${r.caminhoHistorico}`);
+        return 0;
+    }
+    if (sub === 'recall') {
+        const ponteiro = args.posicionais[3];
+        if (!id || !ponteiro) {
+            console.error('uso: ork handoff recall <thread-id> <path#ancora>');
+            return 2;
+        }
+        const r = (0, handoff_1.recall)(carregado, id, ponteiro);
+        console.log(`Ponteiro resolvido: ${r.location}`);
+        console.log(`  metodo       ${r.metodo}`);
+        console.log(`  sha256       ${r.sha256}`);
+        console.log(`  linhas       ${r.intervalo ? `${r.intervalo.inicio}-${r.intervalo.fim}` : '(nao aplicavel)'}`);
+        console.log('');
+        console.log(r.conteudo);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: handoff ${sub}`);
+    return 2;
+}
+function comandoShip(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const id = args.posicionais[1];
+    const para = texto(args.opcoes.para) ?? texto(args.opcoes.to);
+    if (!id || !para) {
+        console.error('uso: ork ship <thread-id> --para <branch> [--de <branch>] [--dry-run]');
+        return 2;
+    }
+    const autorizar = args.opcoes['autorizar-push'];
+    const r = (0, ship_1.ship)(carregado, id, {
+        para,
+        de: texto(args.opcoes.de),
+        remoto: texto(args.opcoes.remoto),
+        mensagem: texto(args.opcoes.mensagem),
+        dryRun: args.opcoes['dry-run'] === true,
+        autorizarPush: typeof autorizar === 'string' ? autorizar : undefined,
+        semPush: args.opcoes['sem-push'] === true,
+    });
+    console.log((0, ship_1.textoDoShip)(r));
+    return r.ok ? 0 : 1;
+}
+function comandoLease(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    if (sub === undefined || sub === 'list') {
+        console.log((0, leases_1.tabelaDeLeases)(carregado.raiz));
+        return 0;
+    }
+    if (sub === 'acquire' || sub === 'take') {
+        const nome = args.posicionais[2];
+        const thread = texto(args.opcoes.thread);
+        const motivo = texto(args.opcoes.motivo) ?? 'sem motivo declarado';
+        if (!nome || !thread) {
+            console.error('uso: ork lease acquire <nome> --thread <thread-id> [--motivo "<motivo>"]');
+            return 2;
+        }
+        (0, thread_1.lerThread)(carregado.raiz, thread);
+        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}`);
+            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(`  posicao na fila: ${r.posicaoNaFila}`);
+        console.error(`  correcao: ${r.correcao}`);
+        return 1;
+    }
+    if (sub === 'release') {
+        const nome = args.posicionais[2];
+        if (!nome) {
+            console.error('uso: ork lease release <nome> [--thread <thread-id>] [--forcar]');
+            return 2;
+        }
+        const r = (0, leases_1.liberar)(carregado.raiz, nome, texto(args.opcoes.thread) ?? '', args.opcoes.forcar === true);
+        console.log(r.detalhe);
+        return r.ok ? 0 : 1;
+    }
+    console.error(`subcomando desconhecido: lease ${sub}`);
+    return 2;
+}
+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)));
+        return 0;
+    }
+    if (sub !== undefined && sub !== 'list') {
+        console.error(`subcomando desconhecido: board ${sub}`);
+        return 2;
+    }
+    console.log((0, board_1.textoDoBoard)(carregado, args.opcoes.all === true || args.opcoes.todos === true));
+    return 0;
+}
+/**
+ * `ork orquestracao status` (alias `ork monitor`): pausas e impedimentos de uma chamada.
+ *
+ * Existe para o orquestrador ser PROATIVO: ele roda isto em laco, ve quem esta parado
+ * esperando veredito humano e avisa o humano com alternativas, em vez de descobrir a
+ * pausa so quando o humano pergunta. O `ork` entrega o estado; quem notifica e a
+ * Camada 1, que consome o `--json`.
+ */
+function comandoOrquestracao(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    if (sub !== undefined && sub !== 'status') {
+        console.error(`subcomando desconhecido: orquestracao ${sub}`);
+        console.error('uso: ork orquestracao status [--all] [--json] [--atencao N] [--so-paradas]');
+        return 2;
+    }
+    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 monitor = (0, orquestracao_1.montarMonitor)(carregado, {
+        todos: args.opcoes.all === true || args.opcoes.todos === true,
+        atencaoMin,
+        soParadas: args.opcoes['so-paradas'] === true,
+        semRuntime: args.opcoes['sem-runtime'] === true,
+    });
+    console.log(args.opcoes.json === true ? JSON.stringify(monitor, null, 2) : (0, orquestracao_1.textoDoMonitor)(monitor));
+    // `--exigir-limpo` transforma o monitor em watchdog: sai != 0 enquanto houver thread
+    // parada. E o que deixa o orquestrador (ou um cron) tratar "tem gente esperando" como
+    // falha acionavel, sem precisar interpretar texto.
+    if (args.opcoes['exigir-limpo'] === true) {
+        return monitor.resumo.aguardandoHumano + monitor.resumo.comImpedimento > 0 ? 1 : 0;
+    }
+    return 0;
+}
+function comandoWorktree(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1];
+    const id = args.posicionais[2];
+    if (!sub || !id) {
+        console.error('uso: ork worktree <ensure|sync|audit|release> <thread-id>');
+        return 2;
+    }
+    if (sub === 'ensure') {
+        const r = (0, worktree_1.garantirWorktree)(carregado, id);
+        if (!r.ok) {
+            console.error(`Worktree da thread ${id} NAO garantida.`);
+            console.error(`  motivo tipado: ${r.motivo}`);
+            console.error(`  detalhe: ${r.detalhe}`);
+            console.error(`  correcao: ${r.correcao}`);
+            return 1;
+        }
+        console.log(r.criada ? `Worktree criada para a thread ${id}.` : `Worktree ja existia para a thread ${id}.`);
+        console.log(`  dir     ${r.dir}`);
+        console.log(`  branch  ${r.branch}`);
+        console.log(`  base    ${r.base} (resolvida pelo ork, nao pelo executor)`);
+        console.log(`  ${r.detalhe}`);
+        return 0;
+    }
+    if (sub === 'sync') {
+        const r = (0, worktree_1.sincronizarWorktree)(carregado, id, { dryRun: args.opcoes['dry-run'] === true });
+        if (!r.ok) {
+            console.error(`Sync da worktree da thread ${id} BLOQUEADO.`);
+            console.error(`  motivo tipado: ${r.motivo}`);
+            console.error(`  detalhe: ${r.detalhe}`);
+            console.error(`  correcao: ${r.correcao}`);
+            return 1;
+        }
+        console.log(r.dryRun ? `Sync (--dry-run) da thread ${id}: nada foi executado.` : `Sync da thread ${id}.`);
+        console.log(`  base       ${r.base} @ ${r.shaBase.slice(0, 8)}`);
+        console.log(`  branch     ${r.branch} @ ${r.shaAntes.slice(0, 8)} -> ${r.shaDepois.slice(0, 8)}`);
+        console.log(`  rebase     ${r.rebaseFeito ? 'feito' : r.jaAtualizada ? 'desnecessario' : 'seria feito'}`);
+        console.log(`  ${r.detalhe}`);
+        if (r.passos.length > 0) {
+            console.log('');
+            console.log('  Comandos reais, na ordem:');
+            for (const passo of r.passos)
+                console.log(`    ${passo}`);
+        }
+        return 0;
+    }
+    if (sub === 'audit') {
+        const r = (0, worktree_1.auditarWorktree)(carregado, id);
+        console.log((0, worktree_1.textoDoAudit)(id, r));
+        return r.ok ? 0 : 1;
+    }
+    if (sub === 'release') {
+        const r = (0, worktree_1.liberarWorktree)(carregado, id, { forcar: args.opcoes.forcar === true });
+        if (!r.ok) {
+            console.error(`Release da worktree da thread ${id} BLOQUEADO.`);
+            console.error(`  motivo tipado: ${r.motivo}`);
+            console.error(`  detalhe: ${r.detalhe}`);
+            console.error(`  correcao: ${r.correcao}`);
+            return 1;
+        }
+        console.log(`Worktree da thread ${id} liberada.`);
+        console.log(`  dir      ${r.dir}`);
+        console.log(`  removida ${r.removida ? 'sim' : 'nao (o diretorio ja nao existia)'}`);
+        console.log(`  leases   ${r.leasesLiberados.join(', ') || '(nenhum lease de escrita para soltar)'}`);
+        console.log(`  ${r.detalhe}`);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: worktree ${sub}`);
+    return 2;
+}
+function comandoMaster(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const primeiro = args.posicionais[1];
+    if (primeiro === 'classes') {
+        console.log((0, master_1.tabelaDeClasses)());
+        return 0;
+    }
+    if (args.opcoes.batch === true || primeiro === 'batch' || primeiro === undefined) {
+        console.log((0, master_1.tabelaDeBatch)(carregado.raiz, args.opcoes.todas === true));
+        return 0;
+    }
+    const id = primeiro;
+    const brutoScore = texto(args.opcoes.score);
+    const justificativa = texto(args.opcoes.justificativa) ?? texto(args.opcoes.porque);
+    if (brutoScore === undefined) {
+        console.error('uso: ork master <thread-id> --score 0-5 --justificativa "<texto>"');
+        console.error('  o score do MASTER e humano, de 0 a 5, e a justificativa e obrigatoria.');
+        return 2;
+    }
+    if (!justificativa) {
+        console.error(`Score RECUSADO para a thread ${id}: falta --justificativa "<texto>".`);
+        console.error('  Score sem justificativa nao vira aprendizado; o `ork` nao o registra.');
+        console.error(`  ork master ${id} --score ${brutoScore} --justificativa "<por que este score>"`);
+        return 2;
+    }
+    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);
+        if (!classe) {
+            console.error(`classe de falha invalida: "${bruta}".`);
+            console.error(`  classes fixas: ${master_1.ORDEM_DAS_CLASSES.join(', ')}`);
+            return 2;
+        }
+        classes.push(classe);
+    }
+    const r = (0, master_1.registrarMaster)(carregado.raiz, id, {
+        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));
+    // 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));
+    console.log('');
+    console.log(`Proximo passo: ork board --all   |   fila de score: ork master --batch`);
+    return 0;
+}
+/**
+ * `ork prompt list|lint|render`: os prompts do `ork` como templates versionados (bloco B4).
+ *
+ * O `lint` reprova template quebrado ANTES de ele virar despacho; o `render` mostra o prompt
+ * 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.
+ */
+function comandoPrompt(args) {
+    const sub = args.posicionais[1] ?? 'list';
+    const carregado = (0, manifest_1.carregarManifesto)();
+    const raiz = carregado?.raiz;
+    if (sub === 'list') {
+        console.log((0, prompts_1.tabelaDeTemplates)((0, prompts_1.carregarTemplates)(raiz)));
+        return 0;
+    }
+    if (sub === 'lint') {
+        const id = texto(args.opcoes.template);
+        const templates = id ? [(0, prompts_1.exigirTemplate)(id, raiz)] : (0, prompts_1.carregarTemplates)(raiz);
+        const problemas = templates.flatMap((t) => (0, prompts_1.lintTemplate)(t));
+        console.log(`Lint dos templates de prompt${raiz ? ` (projeto ${raiz})` : ' (somente embutidos)'}`);
+        console.log('');
+        console.log((0, prompts_1.textoDoLint)(problemas, templates.length));
+        return problemas.some((p) => p.gravidade === 'erro') ? 2 : 0;
+    }
+    if (sub === 'render') {
+        const fase = exigirFaseCanonica(texto(args.opcoes.fase) ?? args.posicionais[3]);
+        const pedido = texto(args.opcoes.pedido) ?? '<pedido do builder>';
+        const idTemplate = texto(args.opcoes.template);
+        // Modo exemplo: renderiza sem thread nenhuma, para revisar o texto de um modo antes de
+        // 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(', ')}`);
+                return 2;
+            }
+            const exemplo = (0, prompts_1.threadDeExemplo)(modo, fase, carregado?.manifesto.project);
+            const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, raiz) : (0, prompts_1.templateDaFase)(fase, raiz);
+            const prompt = (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(exemplo, fase, pedido));
+            console.log(`# template ${template.id} v${template.versao} (origem: ${template.origem})`);
+            console.log(`# thread de EXEMPLO (nada foi gravado), modo ${modos_1.MODOS[modo].tag}, sha256 ${(0, phase_1.hashDoPrompt)(prompt)}`);
+            console.log('');
+            console.log(prompt);
+            return 0;
+        }
+        const obrigatorio = (0, manifest_1.exigirManifesto)();
+        const threadId = args.posicionais[2];
+        if (!threadId) {
+            console.error('uso: ork prompt render <thread-id> <FASE> --pedido "<texto>"');
+            console.error('     ork prompt render --exemplo --fase GOAL --modo auto --pedido "<texto>"');
+            return 2;
+        }
+        const thread = (0, thread_1.lerThread)(obrigatorio.raiz, threadId);
+        const template = idTemplate ? (0, prompts_1.exigirTemplate)(idTemplate, obrigatorio.raiz) : (0, prompts_1.templateDaFase)(fase, obrigatorio.raiz);
+        const prompt = idTemplate
+            ? (0, prompts_1.renderizar)(template, (0, phase_1.valoresDoPrompt)(thread, fase, pedido))
+            : (0, phase_1.montarPrompt)(thread, fase, pedido, obrigatorio.raiz);
+        console.log(`# template ${template.id} v${template.versao} (origem: ${template.origem})`);
+        console.log(`# thread ${thread.id}, fase ${fase}, sha256 ${(0, phase_1.hashDoPrompt)(prompt)}`);
+        console.log('');
+        console.log(prompt);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: prompt ${sub}`);
+    return 2;
+}
+/** Fase canonica a partir do texto do usuario, com erro tipado quando nao existe. */
+function exigirFaseCanonica(bruto) {
+    const alvo = (bruto ?? '').toUpperCase();
+    if (!types_1.FASES.includes(alvo)) {
+        throw new Error(`fase "${bruto ?? ''}" fora do ciclo canonico (${types_1.FASES.join(' ')})`);
+    }
+    return alvo;
+}
+/**
+ * `ork adapter list|show|install <host>`: instalacao dos adaptadores de Camada 1 (bloco B4).
+ */
+function comandoAdapter(args) {
+    const sub = args.posicionais[1] ?? 'list';
+    if (sub === 'list') {
+        console.log((0, hosts_1.tabelaDeHosts)());
+        return 0;
+    }
+    if (sub === 'show') {
+        const host = (0, hosts_1.parseHost)(args.posicionais[2]);
+        if (!host) {
+            console.error(`host desconhecido: "${args.posicionais[2] ?? ''}". Use: ${hosts_1.ORDEM_DOS_HOSTS.join(' | ')}`);
+            return 2;
+        }
+        const def = hosts_1.HOSTS[host];
+        console.log(`Adaptador ${host}`);
+        console.log(`  ${def.descricao}`);
+        console.log(`  destino padrao: <projeto>/${def.destinoPadrao}${def.subdir ? '/' + def.subdir : ''}`);
+        console.log('');
+        console.log((0, hosts_1.textoDosPitfalls)(host));
+        return 0;
+    }
+    if (sub === 'install') {
+        const host = (0, hosts_1.parseHost)(args.posicionais[2]);
+        if (!host) {
+            console.error(`host desconhecido: "${args.posicionais[2] ?? ''}". Use: ${hosts_1.ORDEM_DOS_HOSTS.join(' | ')}`);
+            return 2;
+        }
+        const carregado = (0, manifest_1.carregarManifesto)();
+        const r = (0, hosts_1.instalarAdaptador)(host, {
+            projeto: carregado?.raiz ?? process.cwd(),
+            dir: texto(args.opcoes.dir),
+            dryRun: args.opcoes['dry-run'] === true,
+            force: args.opcoes.force === true || args.opcoes.forcar === true,
+            orkBin: texto(args.opcoes.ork),
+            versao: VERSAO,
+        });
+        console.log((0, hosts_1.textoDaInstalacao)(r));
+        return r.ok ? 0 : 2;
+    }
+    console.error(`subcomando desconhecido: adapter ${sub}`);
+    return 2;
+}
+/**
+ * `ork eval`: canarios de comportamento e o corpus das skills finas (bloco B4).
+ *
+ * Skill sem eval nao entra, e comportamento sem canario tambem nao. O comando sai diferente
+ * de zero em qualquer falha, para o CI do kit poder barrar merge sem eval.
+ */
+function comandoEval(args) {
+    const catalogo = (0, catalogo_1.exigirCatalogo)((0, manifest_1.carregarManifesto)()?.raiz ?? process.cwd());
+    const lista = (v) => {
+        const t = texto(v);
+        return t ? t.split(',').map((x) => x.trim()).filter(Boolean) : undefined;
+    };
+    const r = (0, evalrunner_1.rodarEval)({
+        catalogo,
+        skills: lista(args.opcoes.skill),
+        canarios: lista(args.opcoes.canario) ?? lista(args.opcoes.fixture),
+        soCanarios: args.opcoes['so-canarios'] === true,
+        soSkills: args.opcoes['so-skills'] === true,
+    });
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify(r, null, 2));
+    }
+    else {
+        console.log((0, evalrunner_1.textoDoEval)(r));
+    }
+    return r.ok ? 0 : 1;
+}
+/**
+ * `ork audit ...`: os auditores periodicos (bloco B5).
+ *
+ * O comando existe para ser chamado por CRON e por orquestrador sem sessao interativa:
+ * e por isso que ele mora no CLI deterministico e nao numa skill. Todo subcomando sai
+ * diferente de zero quando reprova, para o agendador do host perceber sem ler texto.
+ */
+function comandoAudit(args) {
+    const sub = args.posicionais[1] ?? 'packs';
+    // `audit packs` e `audit lint` funcionam sem manifesto: sao catalogo, nao estado.
+    if (sub === 'packs' || sub === 'pack') {
+        const carregado = (0, manifest_1.carregarManifesto)();
+        const bruto = texto(args.opcoes.estagio) ?? texto(args.opcoes.stage);
+        const estagio = bruto ? (0, auditoria_1.parseEstagio)(bruto) : carregado?.manifesto.project.stage;
+        if (bruto && !estagio) {
+            console.error(`estagio invalido: "${bruto}". Use: nascente | crescendo | maduro`);
+            return 2;
+        }
+        const pack = texto(args.opcoes.pack) ?? args.posicionais[2];
+        if (pack) {
+            const alvo = (0, auditoria_1.parsePack)(pack);
+            if (!alvo) {
+                console.error(`pack desconhecido: "${pack}". Use um de: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+                return 2;
+            }
+            console.log((0, auditoria_1.textoDoPack)(alvo, estagio ?? undefined));
+            return 0;
+        }
+        console.log(`Packs de auditoria periodica${estagio ? ` (estagio declarado do projeto: ${estagio})` : ''}`);
+        console.log('');
+        console.log((0, auditoria_1.tabelaDePacks)(estagio ?? undefined));
+        if (estagio) {
+            console.log('');
+            console.log(`Ativos aqui e agora: ${(0, auditoria_1.packsAtivos)(estagio).join(', ')}`);
+            console.log(`Postura: ${(0, auditoria_1.posturaDoPack)(estagio)}`);
+        }
+        return 0;
+    }
+    if (sub === 'lint') {
+        const raiz = (0, manifest_1.carregarManifesto)()?.raiz;
+        const templates = (0, auditoria_1.carregarTemplatesDeAuditoria)(raiz);
+        const problemas = templates.flatMap((t) => (0, auditoria_1.lintTemplateDeAuditoria)(t));
+        console.log(`Lint dos templates de auditoria${raiz ? ` (projeto ${raiz})` : ' (somente embutidos)'}`);
+        console.log('');
+        for (const p of problemas) {
+            console.log(`  [${p.gravidade}] ${p.template} :: ${p.regra}`);
+            console.log(`           ${p.detalhe}`);
+        }
+        if (problemas.length === 0)
+            console.log(`  nenhum problema em ${templates.length} template(s)`);
+        console.log('');
+        console.log(`templates: ${templates.length} | erros: ${problemas.filter((p) => p.gravidade === 'erro').length} | ` +
+            `avisos: ${problemas.filter((p) => p.gravidade === 'aviso').length}`);
+        return problemas.some((p) => p.gravidade === 'erro') ? 2 : 0;
+    }
+    const carregado = (0, manifest_1.exigirManifesto)();
+    if (sub === 'run') {
+        const pack = (0, auditoria_1.parsePack)(args.posicionais[2]);
+        if (!pack) {
+            console.error('uso: ork audit run <pack> [--profile P] [--since Nd]');
+            console.error(`  packs: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            return 2;
+        }
+        const autorizar = args.opcoes.agora;
+        const r = (0, auditrun_1.rodarAuditoria)(carregado, pack, {
+            perfil: texto(args.opcoes.profile) ?? texto(args.opcoes.perfil),
+            since: texto(args.opcoes.since),
+            tudo: args.opcoes.tudo === true,
+            effort: texto(args.opcoes.effort),
+            model: texto(args.opcoes.model),
+            dryRun: args.opcoes['dry-run'] === true,
+            agora: typeof autorizar === 'string' ? autorizar : undefined,
+            forcar: args.opcoes.forcar === true || args.opcoes.force === true,
+        });
+        if (r.status === 'bloqueada') {
+            console.error(`Rodada de auditoria ${r.id} BLOQUEADA.`);
+            console.error(`  ${auditoria_1.DESCRICAO_DO_MOTIVO_DE_AUDITORIA[r.motivo ?? 'runtime.unavailable']}`);
+            console.error(`  motivo tipado: ${r.motivo}`);
+            console.error(`  detalhe: ${r.detalhe}`);
+            console.error(`  estado da rodada: .orkastery/audits/${r.id}/run.json`);
+            return 1;
+        }
+        if (r.status === 'ensaio') {
+            console.log(`Simulacao (--dry-run) da rodada ${r.id}: nada foi despachado.`);
+            console.log(`  pack        ${r.pack} (postura ${r.postura} no estagio ${r.estagio})`);
+            console.log(`  escopo      ${r.escopo.detalhe}`);
+            console.log(`  graphify    ${r.escopo.graphify}`);
+            console.log(`  custo       effort ${r.custo.effort}, ${r.custo.janela.detalhe}`);
+            console.log(`  prompt      ${r.promptPath} (sha256 ${r.promptSha256})`);
+            console.log(`  comando     claude --bg "<prompt>" --name ${r.slug} --model ${r.custo.model} --effort ${r.custo.effort}`);
+            if (r.superficie) {
+                console.log(`  superficie  ${r.superficie.detalhe}`);
+                console.log(`              nada registrado no board (--dry-run). Para gravar: ork audit surface --registrar ${r.id}`);
+            }
+            return 0;
+        }
+        console.log(`Rodada de auditoria ${r.id} despachada pelo runtime adapter ${r.runtime}.`);
+        console.log(`  pack        ${r.pack} (${auditoria_1.PACKS[r.pack].titulo})`);
+        console.log(`  produto     ${r.produto} (perfil ${r.perfil}), estagio ${r.estagio}, postura ${r.postura}`);
+        console.log(`  escopo      ${r.escopo.detalhe}`);
+        console.log(`  graphify    ${r.escopo.graphify}`);
+        console.log(`  custo       effort ${r.custo.effort}, model ${r.custo.model}`);
+        console.log(`  janela      ${r.custo.janela.detalhe}`);
+        console.log(`  sessionId   ${r.sessionId}`);
+        console.log(`  prompt      ${r.promptPath} (sha256 ${r.promptSha256})`);
+        console.log(`  verificada no runtime: ${r.verificada ? 'sim' : 'NAO (confira `ork sessions`)'}`);
+        if (r.superficie) {
+            console.log(`  superficie  ${r.superficie.detalhe}`);
+            console.log(`              ${r.superficie.registrados} achado(s) de superficie ja no board de divida` +
+                (r.superficie.aConfirmar > 0
+                    ? `, ${r.superficie.aConfirmar} com confianca baixa (pedem confirmacao humana)`
+                    : ''));
+        }
+        console.log('');
+        console.log('A rodada termina em PROPOSTA para o roadmap, nunca em correcao aplicada.');
+        console.log(`Depois dos achados: ork audit verify ${r.id} && ork audit report ${r.id}`);
+        return r.verificada ? 0 : 1;
+    }
+    if (sub === 'list') {
+        console.log((0, auditrun_1.tabelaDeRodadas)(carregado.raiz));
+        console.log('');
+        console.log(`Board de divida: ${(0, auditrun_1.resumoDoBoard)(carregado.raiz)}`);
+        return 0;
+    }
+    if (sub === 'show') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork audit show <rodada> [--ledger]');
+            return 2;
+        }
+        if (args.opcoes.ledger === true) {
+            console.log((0, auditrun_1.tabelaDoLedgerDaRodada)(carregado.raiz, id));
+            return 0;
+        }
+        console.log((0, auditrun_1.textoDaRodada)(carregado.raiz, id));
+        return 0;
+    }
+    if (sub === 'prompt') {
+        const pack = (0, auditoria_1.parsePack)(args.posicionais[2]);
+        if (!pack) {
+            console.error('uso: ork audit prompt <pack> [--since Nd]');
+            console.error(`  packs: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            return 2;
+        }
+        const { raiz, manifesto } = carregado;
+        const estagio = manifesto.project.stage;
+        const escopo = (0, auditoria_1.escopoDaRodada)(raiz, manifesto, {
+            since: texto(args.opcoes.since),
+            tudo: args.opcoes.tudo === true,
+            pack,
+        });
+        const template = (0, auditoria_1.templateDoPack)(pack, raiz);
+        const prompt = (0, auditoria_1.montarPromptDeAuditoria)({
+            pack,
+            produto: manifesto.project.name,
+            perfil: texto(args.opcoes.profile) ?? manifesto.board.default,
+            estagio,
+            postura: (0, auditoria_1.posturaDoPack)(estagio),
+            rodada: '<rodada ainda nao criada>',
+            dirDaRodada: '.orkastery/audits/<rodada>',
+            escopo,
+            janela: (0, auditoria_1.janelaDeCusto)(manifesto),
+            effort: texto(args.opcoes.effort) ?? manifesto.audit.effort,
+        }, raiz);
+        console.log(`# template ${template.id} v${template.versao} (origem: ${template.origem})`);
+        console.log(`# pack ${pack}, estagio ${estagio}, sha256 ${(0, phase_1.hashDoPrompt)(prompt)}`);
+        console.log('');
+        console.log(prompt);
+        return 0;
+    }
+    if (sub === 'ingest') {
+        const id = args.posicionais[2];
+        const arquivo = texto(args.opcoes.arquivo) ?? texto(args.opcoes.file);
+        if (!id || !arquivo) {
+            console.error('uso: ork audit ingest <rodada> --arquivo <achados.json>');
+            return 2;
+        }
+        const r = (0, auditrun_1.ingerirAchados)(carregado, id, arquivo);
+        console.log(`Ingestao da rodada ${r.rodada}: ${r.registrados.length} achado(s) no board de divida.`);
+        // Bloco B6: cada proposta enderecada ao roadmap tambem vai para a colecao `roadmap`.
+        if (r.registrados.length > 0) {
+            const naMemoria = (0, memoria_1.publicarPropostas)(carregado, r.registrados);
+            if (naMemoria.regime === 'orkmind') {
+                console.log(`Memoria (orkmind): propostas na colecao roadmap, ${naMemoria.detalhe}.`);
+            }
+        }
+        for (const a of r.registrados) {
+            console.log((0, divida_1.textoDoAchado)(a));
+        }
+        if (r.duplicados.length > 0) {
+            console.log('');
+            console.log('Ja registrados nesta rodada, ignorados (a ingestao e idempotente): ' +
+                r.duplicados.map((a) => a.id).join(', '));
+        }
+        if (r.recusados.length > 0) {
+            console.log('');
+            console.error(`RECUSADOS (${r.recusados.length}):`);
+            for (const rec of r.recusados) {
+                console.error(`  achado #${rec.indice + 1}: ${rec.erro}`);
+            }
+        }
+        console.log('');
+        console.log(`Prove os achados antes de qualquer thread: ork audit verify ${r.rodada}`);
+        return r.recusados.length > 0 ? 1 : 0;
+    }
+    if (sub === 'finding' || sub === 'achado') {
+        const acao = args.posicionais[2];
+        if (acao === 'add') {
+            const id = args.posicionais[3];
+            if (!id) {
+                console.error('uso: ork audit finding add <rodada> --regra R --titulo T --arquivo caminho:linha --impacto I --fix F --estimativa E');
+                return 2;
+            }
+            const verificar = texto(args.opcoes.verificar) ?? texto(args.opcoes.verify);
+            const achado = (0, auditrun_1.registrarAchadoDaRodada)(carregado, id, {
+                regra: texto(args.opcoes.regra),
+                severidade: texto(args.opcoes.severidade) ?? texto(args.opcoes.severity),
+                titulo: texto(args.opcoes.titulo),
+                arquivo: texto(args.opcoes.arquivo),
+                descricao: texto(args.opcoes.descricao),
+                alegacao: texto(args.opcoes.alegacao) ?? texto(args.opcoes.claim),
+                verificar: verificar ? [verificar] : [],
+                impacto: texto(args.opcoes.impacto),
+                fix: texto(args.opcoes.fix),
+                irreversivel: texto(args.opcoes.irreversivel) ?? 'nenhum',
+                estimativa: texto(args.opcoes.estimativa),
+            });
+            console.log(`Achado ${achado.id} registrado no board de divida da rodada ${id}.`);
+            console.log((0, divida_1.textoDoAchado)(achado));
+            const naMemoria = (0, memoria_1.publicarPropostas)(carregado, [achado]);
+            if (naMemoria.regime === 'orkmind') {
+                console.log(`Memoria (orkmind): proposta na colecao roadmap, ${naMemoria.detalhe}.`);
+            }
+            return 0;
+        }
+        if (acao === 'estado') {
+            const id = args.posicionais[3];
+            const estado = (0, divida_1.parseEstadoDeAchado)(args.posicionais[4]);
+            if (!id || !estado) {
+                console.error('uso: ork audit finding estado <achado-id> <aberto|adiado|resolvido|descartado>');
+                return 2;
+            }
+            if (estado === 'virou-thread') {
+                console.error('o estado `virou-thread` e carimbado pelo proprio `ork thread new --from-finding`.');
+                return 2;
+            }
+            const achado = (0, divida_1.exigirAchado)(carregado.raiz, id);
+            const atualizado = (0, divida_1.carimbarAchado)(carregado.raiz, achado, { estado });
+            console.log(`Achado ${atualizado.id} agora esta ${atualizado.estado}.`);
+            console.log((0, divida_1.textoDoAchado)(atualizado));
+            return 0;
+        }
+        console.error(`subcomando desconhecido: audit finding ${acao ?? ''}`);
+        return 2;
+    }
+    if (sub === 'verify') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork audit verify <rodada>');
+            return 2;
+        }
+        const v = (0, auditrun_1.verificarRodada)(carregado, id);
+        console.log(`Claims dos achados da rodada ${v.rodada}, reexecutadas no HEAD real.`);
+        console.log(`  HEAD real   ${v.commit}`);
+        console.log(`  diretorio   ${v.cwd}`);
+        console.log('');
+        if (v.resultados.length === 0) {
+            console.log('  (nenhum achado aberto nesta rodada)');
+        }
+        for (const r of v.resultados) {
+            console.log(`  ${r.claim.id}  verificado: ${r.verificado ? 'sim' : 'NAO'}  ${r.claim.alegacao}`);
+            console.log(`      arquivo: ${r.claim.arquivo}`);
+            console.log(`      ${r.claim.verificar.length > 0 ? `comando(s): ${r.claim.verificar.join(' && ')}` : 'sem comando de verificacao'}`);
+            if (!r.verificado)
+                console.log(`      motivo tipado: ${r.motivo} (${r.detalhe})`);
+        }
+        console.log('');
+        console.log(v.ok
+            ? 'Veredito: ACHADOS SUSTENTADOS (o auditor provou o que alegou).'
+            : `Veredito: REPROVADO. Motivos tipados: ${v.motivos.join(', ')}`);
+        if (v.motivos.includes('claims.unverifiable')) {
+            console.log('  aviso: achado sem comando de verificacao avisa e nao bloqueia (regra do gate do B1).');
+        }
+        return v.ok ? 0 : 1;
+    }
+    if (sub === 'report' || sub === 'relatorio') {
+        const id = args.posicionais[2];
+        if (!id) {
+            console.error('uso: ork audit report <rodada> [--publicar]');
+            return 2;
+        }
+        const r = (0, auditrun_1.relatorioDaRodada)(carregado, id, { publicar: args.opcoes.publicar === true });
+        console.log(r.texto);
+        console.log(`(relatorio gravado em ${r.caminho})`);
+        if (r.publicado)
+            console.log(`(publicado em ${r.publicado})`);
+        return 0;
+    }
+    if (sub === 'divida' || sub === 'board') {
+        const bruto = texto(args.opcoes.pack);
+        const pack = bruto ? (0, auditoria_1.parsePack)(bruto) : undefined;
+        if (bruto && !pack) {
+            console.error(`pack desconhecido: "${bruto}". Use um de: ${auditoria_1.ORDEM_DOS_PACKS.join(', ')}`);
+            return 2;
+        }
+        console.log((0, divida_1.tabelaDaDivida)(carregado.raiz, {
+            pack: pack ?? undefined,
+            todos: args.opcoes.todos === true || args.opcoes.all === true,
+        }));
+        return 0;
+    }
+    // `audit surface`: a varredura deterministica da superficie de ataque de rede (SP8..SP12).
+    // Ela roda sozinha dentro de `audit run security-privacy`; aqui ela e exposta para o
+    // operador olhar a superficie sem despachar rodada nenhuma, e para registrar no board os
+    // achados de uma rodada que rodou em `--dry-run`.
+    if (sub === 'surface' || sub === 'superficie') {
+        const bruta = texto(args.opcoes.regra);
+        if (bruta && !superficie_1.REGRAS_DE_SUPERFICIE.includes(bruta.toUpperCase())) {
+            console.error(`regra desconhecida: "${bruta}". Use uma de: ${superficie_1.REGRAS_DE_SUPERFICIE.join(', ')}`);
+            return 2;
+        }
+        const regra = bruta ? bruta.toUpperCase() : undefined;
+        const limiteBruto = texto(args.opcoes.limite);
+        const limite = limiteBruto ? Number(limiteBruto) : undefined;
+        if (limite !== undefined && (!Number.isFinite(limite) || limite < 1)) {
+            console.error(`--limite invalido: "${limiteBruto}". Use um inteiro >= 1.`);
+            return 2;
+        }
+        const rodadaAlvo = texto(args.opcoes.registrar);
+        if (rodadaAlvo) {
+            const r = (0, auditrun_1.varrerSuperficieDaRodada)(carregado, rodadaAlvo, { registrar: true, limitePorRegra: limite });
+            console.log((0, superficie_1.textoDaVarredura)(r.resultado));
+            console.log('');
+            console.log(`Rodada ${r.rodada}: ${r.registrados.length} achado(s) registrado(s) no board de divida.`);
+            for (const a of r.registrados)
+                console.log(`  ${a.id}  ${a.regra}  ${a.arquivo}:${a.linha}  ${a.titulo}`);
+            if (r.duplicados.length > 0) {
+                console.log(`  ja registrados nesta rodada: ${r.duplicados.map((a) => a.id).join(', ')}`);
+            }
+            for (const rec of r.recusados) {
+                console.error(`  RECUSADO ${rec.achado.regra} ${rec.achado.arquivo}:${rec.achado.linha}: ${rec.erro}`);
+            }
+            console.log('');
+            console.log(`Prove os achados antes de qualquer thread: ork audit verify ${r.rodada}`);
+            if (r.recusados.length > 0)
+                return 1;
+            return r.registrados.length > 0 ? 1 : 0;
+        }
+        const resultado = (0, superficie_1.varrerSuperficie)(carregado.raiz, {
+            dir: args.posicionais[2],
+            regra,
+            limitePorRegra: limite,
+        });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(resultado, null, 2));
+        }
+        else {
+            console.log((0, superficie_1.textoDaVarredura)(resultado));
+        }
+        // Codigo != 0 com achado: o agendador do host percebe a superficie aberta sem ler texto.
+        return resultado.achados.length > 0 ? 1 : 0;
+    }
+    console.error(`subcomando desconhecido: audit ${sub}`);
+    return 2;
+}
+/** Roteia o comando. Devolve o codigo de saida do processo. */
+/**
+ * Imprime o resultado de uma publicacao na memoria semantica (bloco B6).
+ *
+ * Em regime `files` ele nao imprime nada: o comando que chamou continua com a mesma saida
+ * que sempre teve. E o que garante que ligar o B6 nao muda o que o builder ja conhece.
+ */
+function relatarPublicacao(r) {
+    if (r.regime !== 'orkmind')
+        return;
+    const gravados = [
+        `${r.decisoes.gravadas.filter((g) => g.ok).length} decision`,
+        `${r.policies.gravadas.filter((g) => g.ok).length} rule`,
+        r.handoff?.ok ? '1 handoff' : '',
+        r.learning?.ok ? '1 learning' : '',
+        r.roadmap?.ok ? '1 roadmap' : '',
+    ].filter((t) => t !== '');
+    console.log('');
+    console.log(`Memoria (orkmind, tenant ${r.estado.tenant}): ${gravados.join(', ') || 'nada a gravar'}.`);
+    if (r.falhas > 0)
+        console.log(`  ${r.falhas} gravacao(oes) nao concluida(s); veja ork memory status.`);
+}
+/** `ork recall`: recuperacao tardia dos ponteiros do handoff, no momento indicado. */
+function comandoRecall(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const id = args.posicionais[1];
+    if (!id) {
+        console.error('uso: ork recall <thread-id> [--fase FASE] [--id ptr-N] [--todos] [--forcar]');
+        return 2;
+    }
+    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 r = (0, recall_1.recallDaThread)(carregado, memoria, id, {
+        momento,
+        id: texto(args.opcoes.id),
+        todos: args.opcoes.todos === true,
+        forcar: args.opcoes.forcar === true,
+    });
+    if (args.opcoes.json === true) {
+        console.log(JSON.stringify(r, null, 2));
+    }
+    else {
+        console.log((0, recall_1.textoDoRecall)(r, args.opcoes['sem-conteudo'] !== true));
+    }
+    // Ponteiro que deveria resolver e nao resolveu e falha, nao relatorio.
+    return r.falhas.length > 0 ? 1 : 0;
+}
+/** `ork memory`: o regime, a publicacao e a busca deterministica por tag. */
+function comandoMemory(args) {
+    const carregado = (0, manifest_1.exigirManifesto)();
+    const sub = args.posicionais[1] ?? 'status';
+    const memoria = (0, memoria_1.abrirMemoria)(carregado);
+    if (sub === 'status') {
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(memoria.estado, null, 2));
+            return 0;
+        }
+        console.log((0, memoria_1.textoDoEstado)(memoria.estado));
+        return 0;
+    }
+    if (sub === 'sync') {
+        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);
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(r, null, 2));
+        }
+        else {
+            console.log((0, memoria_1.textoDoSync)(r));
+        }
+        return 0;
+    }
+    if (sub === 'search') {
+        const tagsBrutas = texto(args.opcoes.tags);
+        if (!tagsBrutas) {
+            console.error('uso: ork memory search --tags \'{"project":["orkastery"],"skill":["orkastery-decision"]}\'');
+            return 2;
+        }
+        let tags;
+        try {
+            tags = JSON.parse(tagsBrutas);
+        }
+        catch (e) {
+            console.error(`--tags nao e JSON valido: ${e.message}`);
+            return 2;
+        }
+        const colecao = texto(args.opcoes.colecao) ?? texto(args.opcoes.collection);
+        const limiteBruto = texto(args.opcoes.limite);
+        const entradas = memoria.buscar({
+            collection: colecao,
+            tags,
+            limite: limiteBruto ? Number(limiteBruto) : undefined,
+        });
+        if (args.opcoes.json === true) {
+            console.log(JSON.stringify(entradas, null, 2));
+            return 0;
+        }
+        console.log(`Busca deterministica por tag (regime ${memoria.regime})`);
+        console.log('');
+        if (memoria.regime === 'files') {
+            console.log(`  ${memoria.estado.detalhe}`);
+            console.log(`  correcao: ${memoria.estado.correcao}`);
+            return 0;
+        }
+        for (const e of entradas) {
+            console.log(`  [${e.collection}] ${e.id}  ${e.priority}${e.mandatory ? ' [MANDATORY]' : ''}`);
+            console.log(`      ${e.content.split('\n')[0].slice(0, 100)}`);
+        }
+        console.log('');
+        console.log(`  ${entradas.length} entrada(s)`);
+        return 0;
+    }
+    console.error(`subcomando desconhecido: memory ${sub}`);
+    return 2;
+}
+function main(argv) {
+    const args = parseArgs(argv);
+    const comando = args.posicionais[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;
+    }
+    switch (comando) {
+        case 'doctor': {
+            const r = (0, doctor_1.doctor)();
+            console.log(r.texto);
+            return r.codigo;
+        }
+        case 'init': {
+            const r = (0, init_1.init)(process.cwd(), {
+                force: args.opcoes.force === true,
+                nome: texto(args.opcoes.name) ?? texto(args.opcoes.nome),
+                abbrev: texto(args.opcoes.abbrev),
+            });
+            if (!r.criado) {
+                console.log(`Manifesto ja existe: ${r.caminho}`);
+                console.log('Nada foi sobrescrito. Use --force para regerar.');
+                return 0;
+            }
+            console.log(`Manifesto criado: ${r.caminho}`);
+            console.log(`  projeto     ${r.deteccao.nome} (abbrev "${r.deteccao.abbrev}")`);
+            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('');
+            console.log('Proximo passo: ork doctor');
+            return 0;
+        }
+        case 'modos': {
+            // `--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)();
+                const extraido = (0, modos_1.extrairTagDoPedido)(pedido);
+                const modo = extraido ?? carregado?.manifesto.conduction.default_mode ?? 'classic';
+                if (args.opcoes.json === true) {
+                    console.log(JSON.stringify({
+                        modo,
+                        tag: modos_1.MODOS[modo].tag,
+                        daTag: extraido !== null,
+                        origem: extraido !== null ? 'tag no pedido' : 'conduction.default_mode',
+                        pausas: (0, modos_1.pausasDoModo)(modo),
+                    }));
+                }
+                else {
+                    console.log(modo);
+                }
+                return 0;
+            }
+            console.log((0, modos_1.tabelaDeModos)());
+            return 0;
+        }
+        case 'thread':
+            return comandoThread(args);
+        case 'phase':
+            return comandoPhase(args);
+        case 'sessions':
+            return comandoSessions(args);
+        case 'claims':
+            return comandoClaims(args);
+        case 'verify':
+            return comandoVerify(args);
+        case 'gate':
+            return comandoGate(args);
+        case 'retry':
+            return comandoRetry(args);
+        case 'fix':
+            return comandoFix(args);
+        case 'handoff':
+            return comandoHandoff(args);
+        case 'recall':
+            return comandoRecall(args);
+        case 'memory':
+            return comandoMemory(args);
+        case 'ship':
+            return comandoShip(args);
+        case 'lease':
+            return comandoLease(args);
+        case 'board':
+            return comandoBoard(args);
+        case 'orquestracao':
+        case 'monitor':
+            return comandoOrquestracao(args);
+        case 'worktree':
+            return comandoWorktree(args);
+        case 'master':
+            return comandoMaster(args);
+        case 'eval':
+            return comandoEval(args);
+        case 'audit':
+            return comandoAudit(args);
+        case 'adapter':
+            return comandoAdapter(args);
+        case 'prompt':
+            return comandoPrompt(args);
+        case 'ciclos':
+            console.log((0, ciclos_1.tabelaDeVariantes)());
+            return 0;
+        default:
+            console.error(`comando desconhecido: ${comando}`);
+            console.log(AJUDA);
+            return 2;
+    }
+}
+if (require.main === module) {
+    try {
+        process.exitCode = main(process.argv.slice(2));
+    }
+    catch (e) {
+        console.error(`erro: ${e.message}`);
+        process.exitCode = 1;
+    }
+}