@orkastery/cli 0.2.0

package/dist/divida.js

@@ -0,0 +1,374 @@
+"use strict";
+/**
+ * O board de divida: onde os achados e as propostas de ajuste ficam (bloco B5).
+ *
+ * Toda rodada de auditoria termina em PROPOSTA enderecada ao roadmap do produto, nunca em
+ * correcao aplicada. O board e o registro append-only dessas propostas: e dele que o
+ * `ork thread new --from-finding <id>` tira o achado, e e nele que a RECORRENCIA de uma
+ * regra e contada (a regra mecanica herdada do `ork learn`: 2 recorrencias propoem
+ * controle, 3 propoem bloqueante).
+ *
+ * Duas regras estruturais moram aqui:
+ *   1. achado sem proposta COMPLETA nao entra (`achado.sem-proposta`), o que torna o bloco
+ *      obrigatorio de propostas uma garantia do formato de dados e nao um pedido no prompt;
+ *   2. o achado carrega uma CLAIM montada pela MESMA regra das claims de fase
+ *      (`montarClaim`), porque o auditor nao tem direito a self-report.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CAMPOS_DA_PROPOSTA = exports.SEVERIDADES = void 0;
+exports.dirDivida = dirDivida;
+exports.caminhoBoard = caminhoBoard;
+exports.lerBoard = lerBoard;
+exports.proximoIdDeAchado = proximoIdDeAchado;
+exports.gravarAchado = gravarAchado;
+exports.exigirAchado = exigirAchado;
+exports.parseSeveridade = parseSeveridade;
+exports.separarArquivoELinha = separarArquivoELinha;
+exports.faltasDaProposta = faltasDaProposta;
+exports.acharDuplicado = acharDuplicado;
+exports.registrarAchado = registrarAchado;
+exports.carimbarAchado = carimbarAchado;
+exports.achadosDaRodada = achadosDaRodada;
+exports.recorrencias = recorrencias;
+exports.abertos = abertos;
+exports.parseEstadoDeAchado = parseEstadoDeAchado;
+exports.tabelaDaDivida = tabelaDaDivida;
+exports.textoDoAchado = textoDoAchado;
+exports.pedidoDoAchado = pedidoDoAchado;
+const path = __importStar(require("node:path"));
+const claims_1 = require("./claims");
+const manifest_1 = require("./manifest");
+const auditoria_1 = require("./auditoria");
+const util_1 = require("./util");
+/** Diretorio do board de divida do projeto. */
+function dirDivida(raiz) {
+    return path.join((0, manifest_1.dirEstado)(raiz), 'divida');
+}
+/** O board em si, append-only como o ledger e o `claims.jsonl`. */
+function caminhoBoard(raiz) {
+    return path.join(dirDivida(raiz), 'board.jsonl');
+}
+/** Le o board (armazem JSONL: a ultima gravacao de um id vence, como no `claims.jsonl`). */
+function lerBoard(raiz) {
+    return (0, util_1.lerJsonl)(caminhoBoard(raiz));
+}
+/** Proximo id sequencial do board (`F1`, `F2`, ...), unico no projeto. */
+function proximoIdDeAchado(achados) {
+    return (0, util_1.proximoIdSequencial)(achados.map((a) => a.id), 'F');
+}
+/** Anexa o achado ao board (append-only). */
+function gravarAchado(raiz, achado) {
+    (0, util_1.anexarJsonl)(caminhoBoard(raiz), achado);
+}
+/** Acha um achado pelo id, com erro acionavel quando ele nao existe. */
+function exigirAchado(raiz, id) {
+    const achado = lerBoard(raiz).find((a) => a.id === id.toUpperCase());
+    if (!achado) {
+        throw new Error(`achado "${id}" nao existe no board de divida (${caminhoBoard(raiz)}). Veja: ork audit divida`);
+    }
+    return achado;
+}
+/** Severidades aceitas, para o parse do que vem do auditor. */
+exports.SEVERIDADES = ['critico', 'maior', 'menor'];
+/** Severidade valida, ou null. */
+function parseSeveridade(bruto) {
+    const alvo = (bruto ?? '').trim().toLowerCase();
+    return exports.SEVERIDADES.includes(alvo) ? alvo : null;
+}
+/** Separa `caminho/arquivo.ts:42` em caminho e linha. Sem linha, a linha e null. */
+function separarArquivoELinha(bruto) {
+    const casado = /^(.*):(\d+)$/.exec(bruto.trim());
+    if (!casado)
+        return { arquivo: bruto.trim(), linha: null };
+    return { arquivo: casado[1], linha: Number(casado[2]) };
+}
+/**
+ * Os campos que compoem a proposta de ajuste, com o texto que o auditor le no FORMATO.md.
+ *
+ * Fonte UNICA: a validacao (`faltasDaProposta`) e a documentacao que a rodada deixa para o
+ * auditor saem desta lista. Antes ela existia em codigo e em duas prosas independentes, e
+ * foi o proprio pack `reuse` que apontou isso (regra RU4) na rodada ork-reuse-2026-09-03-1.
+ */
+exports.CAMPOS_DA_PROPOSTA = [
+    { campo: 'titulo', rotulo: 'titulo', descricao: 'uma linha, o que esta errado' },
+    {
+        campo: 'arquivo',
+        rotulo: 'arquivo (evidencia caminho:linha)',
+        descricao: 'a evidencia principal, no formato caminho/do/arquivo.ext:42',
+    },
+    { campo: 'impacto', rotulo: 'impacto', descricao: 'o que quebra ou custa se ficar como esta' },
+    { campo: 'fix', rotulo: 'fix sugerido', descricao: 'o ajuste proposto, em uma frase' },
+    {
+        campo: 'irreversivel',
+        rotulo: 'passo irreversivel (escreva "nenhum" quando o fix for reversivel)',
+        descricao: 'o passo irreversivel do fix, ou "nenhum"',
+    },
+    { campo: 'estimativa', rotulo: 'estimativa', descricao: '2h | 1d | 1 semana' },
+];
+/**
+ * Valida a proposta de ajuste.
+ *
+ * Os campos abaixo sao o bloco obrigatorio da visao (secao 5.1): evidencia arquivo:linha,
+ * impacto, fix sugerido, passo irreversivel e estimativa. Sem eles o achado nao vira insumo
+ * de roadmap, e um achado que nao vira insumo de roadmap e relatorio, que e exatamente o
+ * que o B5 nao pode produzir.
+ */
+function faltasDaProposta(entrada) {
+    const faltas = [];
+    for (const { campo, rotulo } of exports.CAMPOS_DA_PROPOSTA) {
+        if (String(entrada[campo] ?? '').trim() === '')
+            faltas.push(rotulo);
+    }
+    const pack = auditoria_1.PACKS[entrada.pack];
+    if (pack && !pack.regras.some((r) => r.id === entrada.regra)) {
+        faltas.push(`regra "${entrada.regra}" fora do pack ${entrada.pack} (validas: ${pack.regras.map((r) => r.id).join(', ')})`);
+    }
+    return faltas;
+}
+/**
+ * O mesmo achado ja registrado NESTA rodada, se houver.
+ *
+ * A chave e (rodada, pack, regra, evidencia, titulo). De proposito ela nao atravessa
+ * rodadas: o mesmo achado voltando numa rodada POSTERIOR e recorrencia, que e justamente
+ * o sinal que promove policy. Duplicata dentro da mesma rodada e outra coisa: e a mesma
+ * leitura contada duas vezes, e ela inflaria a recorrencia sem nenhum fato novo.
+ */
+function acharDuplicado(achados, entrada) {
+    const { arquivo, linha } = separarArquivoELinha(entrada.arquivo);
+    return (achados.find((a) => a.rodada === entrada.rodada &&
+        a.pack === entrada.pack &&
+        a.regra === entrada.regra &&
+        a.arquivo === arquivo &&
+        a.linha === linha &&
+        a.titulo === (entrada.titulo ?? '').trim()) ?? null);
+}
+/**
+ * Registra um achado no board de divida.
+ *
+ * Nao grava no ledger: quem registra o evento e a rodada que chamou, porque o ledger da
+ * auditoria pertence a rodada e nao ao board.
+ */
+function registrarAchado(raiz, entrada) {
+    const faltas = faltasDaProposta(entrada);
+    if (faltas.length > 0) {
+        throw new Error(`achado.sem-proposta: a proposta de ajuste esta incompleta (faltam: ${faltas.join(', ')}). ` +
+            'Cada achado precisa terminar em proposta enderecada ao roadmap do produto.');
+    }
+    const board = lerBoard(raiz);
+    const id = proximoIdDeAchado(board);
+    const { arquivo, linha } = separarArquivoELinha(entrada.arquivo);
+    const proposta = {
+        impacto: entrada.impacto.trim(),
+        fix: entrada.fix.trim(),
+        estimativa: entrada.estimativa.trim(),
+        passoIrreversivel: (entrada.irreversivel ?? '').trim(),
+        destino: `roadmap do produto ${entrada.produto}`,
+        regime: entrada.memory,
+    };
+    // A claim do achado nasce pela MESMA regra das claims de fase: o auditor tambem nao
+    // pode alegar sem declarar como se comprova.
+    const claim = (0, claims_1.montarClaim)({
+        id: `${id}.C1`,
+        dono: entrada.rodada,
+        fase: null,
+        arquivo: entrada.arquivo.trim(),
+        alegacao: (entrada.alegacao ?? entrada.titulo).trim(),
+        verificar: entrada.verificar,
+    });
+    const achado = {
+        id,
+        rodada: entrada.rodada,
+        pack: entrada.pack,
+        regra: entrada.regra,
+        severidade: entrada.severidade,
+        titulo: entrada.titulo.trim(),
+        arquivo,
+        linha,
+        descricao: entrada.descricao.trim(),
+        proposta,
+        claim,
+        estado: 'aberto',
+        produto: entrada.produto,
+        estagio: entrada.estagio,
+        postura: entrada.postura,
+        registradoEm: (0, util_1.agora)(),
+        thread: null,
+    };
+    gravarAchado(raiz, achado);
+    return achado;
+}
+/** Regrava o achado com o novo estado (o append mais novo vence). */
+function carimbarAchado(raiz, achado, mudanca) {
+    const atualizado = { ...achado, ...mudanca };
+    gravarAchado(raiz, atualizado);
+    return atualizado;
+}
+/** Achados de uma rodada, na ordem do board. */
+function achadosDaRodada(raiz, rodada) {
+    return lerBoard(raiz).filter((a) => a.rodada === rodada);
+}
+/**
+ * Recorrencia por (pack, regra) no board de divida.
+ *
+ * A regra de promocao e MECANICA e vem da visao (secao 5.2 e onboarding secao 4): 2
+ * recorrencias PROPOEM um controle, 3 PROPOEM tornar a policy bloqueante. O `ork` nunca
+ * promove sozinho: promover policy e decisao do humano, e o board so mostra a conta.
+ */
+function recorrencias(achados) {
+    const grupos = new Map();
+    for (const a of achados) {
+        // Achado descartado nao procedia e achado resolvido ja foi pago: nenhum dos dois conta
+        // como recorrencia, senao a conta que propoe promover policy mediria divida quitada.
+        if (a.estado === 'descartado' || a.estado === 'resolvido')
+            continue;
+        const chave = `${a.pack}::${a.regra}`;
+        grupos.set(chave, [...(grupos.get(chave) ?? []), a]);
+    }
+    const saida = [];
+    for (const [chave, lista] of grupos) {
+        const [pack, regra] = chave.split('::');
+        const n = lista.length;
+        const promocao = n >= 3 ? 'bloqueante' : n === 2 ? 'controle' : 'nenhuma';
+        saida.push({
+            pack: pack,
+            regra,
+            ocorrencias: n,
+            achados: lista.map((a) => a.id),
+            promocaoProposta: promocao,
+            detalhe: promocao === 'bloqueante'
+                ? `${n} recorrencias: o board PROPOE promover a policy correspondente para block`
+                : promocao === 'controle'
+                    ? `${n} recorrencias: o board PROPOE um controle para a regra ${regra}`
+                    : 'primeira ocorrencia: sem promocao proposta',
+        });
+    }
+    return saida.sort((a, b) => b.ocorrencias - a.ocorrencias || a.pack.localeCompare(b.pack) || a.regra.localeCompare(b.regra));
+}
+/** Estados que continuam pendentes de decisao do humano. */
+function abertos(achados) {
+    return achados.filter((a) => a.estado === 'aberto');
+}
+/** Estado valido a partir do texto do usuario, ou null. */
+function parseEstadoDeAchado(bruto) {
+    const alvo = (bruto ?? '').trim().toLowerCase();
+    const validos = ['aberto', 'virou-thread', 'adiado', 'resolvido', 'descartado'];
+    return validos.includes(alvo) ? alvo : null;
+}
+/** Tabela de `ork audit divida`. */
+function tabelaDaDivida(raiz, filtro = {}) {
+    const board = lerBoard(raiz);
+    const alvo = board
+        .filter((a) => (filtro.pack ? a.pack === filtro.pack : true))
+        .filter((a) => (filtro.todos ? true : a.estado !== 'descartado' && a.estado !== 'resolvido'));
+    if (alvo.length === 0) {
+        return ('Board de divida vazio' +
+            (filtro.pack ? ` para o pack ${filtro.pack}` : '') +
+            `.\nRode uma auditoria: ork audit run <pack>`);
+    }
+    const linhas = alvo.map((a) => [
+        a.id,
+        a.pack,
+        a.regra,
+        a.severidade,
+        a.claim.estado,
+        a.estado,
+        a.proposta.estimativa,
+        a.proposta.passoIrreversivel.toLowerCase() === 'nenhum' ? 'nao' : 'SIM',
+        `${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`,
+        a.titulo,
+    ]);
+    const corpo = (0, util_1.tabela)(['ID', 'PACK', 'REGRA', 'SEVERIDADE', 'CLAIM', 'ESTADO', 'ESTIMATIVA', 'IRREVERSIVEL', 'EVIDENCIA', 'TITULO'], linhas);
+    const rec = recorrencias(alvo).filter((r) => r.ocorrencias > 1);
+    const linhasRec = rec.length === 0
+        ? ['  (nenhuma regra recorrente ainda)']
+        : rec.map((r) => `  ${r.pack} ${r.regra}: ${r.ocorrencias}x -> promocao proposta: ${r.promocaoProposta} (${r.achados.join(', ')})`);
+    return [
+        `Board de divida do projeto (${caminhoBoard(raiz)})`,
+        '',
+        corpo,
+        '',
+        'Recorrencia (2 propoem controle, 3 propoem bloqueante; o `ork` nunca promove sozinho):',
+        ...linhasRec,
+        '',
+        `abertos: ${abertos(alvo).length} | total listado: ${alvo.length}`,
+        'Achado vira thread com: ork thread new "<nome>" --from-finding <ID>',
+    ].join('\n');
+}
+/** Detalhe de um achado, usado pelo `--from-finding` e por `ork audit show`. */
+function textoDoAchado(a) {
+    const linhas = [];
+    linhas.push(`  ${a.id}  [${a.severidade}] ${a.pack}/${a.regra}  ${a.titulo}`);
+    linhas.push(`      evidencia   ${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`);
+    if (a.descricao)
+        linhas.push(`      descricao   ${a.descricao}`);
+    linhas.push(`      claim       ${a.claim.id} [${a.claim.estado}] ${a.claim.alegacao}`);
+    linhas.push(`      verificar   ${a.claim.verificar.join(' && ') || '(sem comando: o auditor nao comprovou o achado)'}`);
+    linhas.push(`      impacto     ${a.proposta.impacto}`);
+    linhas.push(`      fix         ${a.proposta.fix}`);
+    linhas.push(`      irreversivel ${a.proposta.passoIrreversivel}`);
+    linhas.push(`      estimativa  ${a.proposta.estimativa}`);
+    linhas.push(`      destino     ${a.proposta.destino} (regime ${a.proposta.regime})`);
+    linhas.push(`      estado      ${a.estado}${a.thread ? ` (thread ${a.thread})` : ''}`);
+    return linhas.join('\n');
+}
+/**
+ * O texto do GOAL que um achado entrega a thread aberta por `--from-finding`.
+ *
+ * E o "sem retrabalho" da visao: o pedido do builder ja nasce com a evidencia, o impacto, o
+ * fix proposto, o passo irreversivel e a estimativa que o auditor levantou.
+ */
+function pedidoDoAchado(a) {
+    return [
+        `Achado de auditoria ${a.id} (pack ${a.pack}, regra ${a.regra}, severidade ${a.severidade}).`,
+        '',
+        `Titulo: ${a.titulo}`,
+        `Evidencia: ${a.arquivo}${a.linha !== null ? ':' + a.linha : ''}`,
+        a.descricao ? `Descricao: ${a.descricao}` : '',
+        `Alegacao do auditor (claim ${a.claim.id}, estado ${a.claim.estado}): ${a.claim.alegacao}`,
+        `Como reexecutar a evidencia: ${a.claim.verificar.join(' && ') || '(nao declarado pelo auditor)'}`,
+        '',
+        'Proposta de ajuste levantada pela rodada:',
+        `  impacto       ${a.proposta.impacto}`,
+        `  fix sugerido  ${a.proposta.fix}`,
+        `  irreversivel  ${a.proposta.passoIrreversivel}`,
+        `  estimativa    ${a.proposta.estimativa}`,
+        '',
+        `Origem: rodada ${a.rodada}, produto ${a.produto}, estagio ${a.estagio}, postura ${a.postura}.`,
+        'O fix acima e proposta do auditor, nao decisao: valide no GOAL antes de implementar.',
+    ]
+        .filter((l) => l !== '')
+        .join('\n');
+}

package/dist/doctor.js

@@ -0,0 +1,246 @@
+"use strict";
+/**
+ * `ork doctor`: o que vale nesta maquina agora.
+ *
+ * Cada check tem nivel (`ok`, `warn`, `fail`) e, quando falha, a acao de correcao.
+ * Qualquer `fail` faz o comando sair com codigo diferente de zero: e um gate, nao um relatorio.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checar = checar;
+exports.relatorio = relatorio;
+exports.doctor = doctor;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const adapter = __importStar(require("./adapters/claude-bg"));
+const manifest_1 = require("./manifest");
+const modos_1 = require("./modos");
+const orkmind_1 = require("./orkmind");
+const ratelimit_1 = require("./ratelimit");
+const slug_1 = require("./slug");
+const util_1 = require("./util");
+/**
+ * Variaveis que REDIRECIONAM o despacho do `claude` para um provider pago.
+ * Presenca delas com politica `subscription-only` e bloqueante (a licao dos US$ 16).
+ */
+const ENVS_QUE_REDIRECIONAM = [
+    'ANTHROPIC_API_KEY',
+    'ANTHROPIC_AUTH_TOKEN',
+    'ANTHROPIC_BASE_URL',
+    'CLAUDE_CODE_USE_BEDROCK',
+    'CLAUDE_CODE_USE_VERTEX',
+];
+/**
+ * Variaveis de provider pago que nao mudam o despacho do `claude`, mas indicam
+ * credencial cobrada por token no ambiente. Viram aviso, nao bloqueio.
+ */
+const ENVS_DE_PROVIDER_PAGO = ['OPENROUTER_API_KEY', 'OPENAI_API_KEY', 'GEMINI_API_KEY'];
+function versaoNode() {
+    return Number(process.versions.node.split('.')[0]);
+}
+/** Roda todos os checks a partir do diretorio informado. */
+function checar(dirInicial = process.cwd()) {
+    const checks = [];
+    const major = versaoNode();
+    checks.push({
+        nome: 'node',
+        nivel: major >= 20 ? 'ok' : 'fail',
+        detalhe: `v${process.versions.node}`,
+        correcao: major >= 20 ? undefined : 'instale Node 20 ou superior',
+    });
+    const git = (0, util_1.noPath)('git');
+    checks.push({
+        nome: 'git',
+        nivel: git ? 'ok' : 'fail',
+        detalhe: git ?? 'nao encontrado no PATH',
+        correcao: git ? undefined : 'instale o git',
+    });
+    const repo = (0, util_1.exec)('git', ['rev-parse', '--is-inside-work-tree'], dirInicial);
+    const dentroDeRepo = repo.ok && repo.stdout.trim() === 'true';
+    const branch = (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], dirInicial);
+    checks.push({
+        nome: 'repositorio',
+        nivel: dentroDeRepo ? 'ok' : 'fail',
+        detalhe: dentroDeRepo ? `branch ${branch.stdout.trim()}` : 'fora de um repositorio git',
+        correcao: dentroDeRepo ? undefined : 'rode o ork dentro de um repositorio git',
+    });
+    const claude = adapter.disponivel();
+    const v = claude ? adapter.versao() : null;
+    checks.push({
+        nome: 'runtime claude-bg',
+        nivel: claude ? 'ok' : 'fail',
+        detalhe: claude ? `${claude} (${v ?? 'versao desconhecida'})` : 'binario `claude` fora do PATH',
+        correcao: claude ? undefined : 'instale o Claude Code e garanta `claude` no PATH',
+    });
+    const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
+    if (!carregado) {
+        checks.push({
+            nome: 'manifesto',
+            nivel: 'fail',
+            detalhe: `${manifest_1.NOME_MANIFESTO} nao encontrado a partir de ${dirInicial}`,
+            correcao: 'ork init',
+        });
+    }
+    else {
+        checks.push({
+            nome: 'manifesto',
+            nivel: carregado.erros.length > 0 ? 'fail' : carregado.avisos.length > 0 ? 'warn' : 'ok',
+            detalhe: carregado.erros.length > 0
+                ? `${carregado.caminho}: ${carregado.erros.join('; ')}`
+                : `${carregado.caminho} (${carregado.bytes} B de ${manifest_1.LIMITE_MANIFESTO_BYTES})` +
+                    (carregado.avisos.length > 0 ? `; ${carregado.avisos.join('; ')}` : ''),
+            correcao: carregado.erros.length > 0 ? 'corrija o manifesto e rode ork doctor de novo' : undefined,
+        });
+        const abbrev = carregado.manifesto.project.abbrev;
+        const checkAbbrev = (0, slug_1.validarAbbrev)(abbrev);
+        checks.push({
+            nome: 'abbrev do projeto',
+            nivel: checkAbbrev.ok ? 'ok' : 'fail',
+            detalhe: checkAbbrev.ok
+                ? `"${abbrev}" (parte 1 do slug de sessao)`
+                : checkAbbrev.erro,
+            correcao: checkAbbrev.ok ? undefined : 'defina project.abbrev com ate 3 caracteres [a-z0-9]',
+        });
+        const cond = carregado.manifesto.conduction;
+        checks.push({
+            nome: 'modos de conducao',
+            nivel: 'ok',
+            detalhe: `padrao ${modos_1.MODOS[cond.default_mode].tag}; ` +
+                `permitidos ${cond.allowed_modes.map((m) => modos_1.MODOS[m].tag).join(', ')}`,
+        });
+        const politica = carregado.manifesto.runtime.provider_policy;
+        const soAssinatura = politica === 'subscription-only';
+        const redirecionam = ENVS_QUE_REDIRECIONAM.filter((e) => (process.env[e] ?? '').trim() !== '');
+        const pagas = ENVS_DE_PROVIDER_PAGO.filter((e) => (process.env[e] ?? '').trim() !== '');
+        const bloqueia = soAssinatura && redirecionam.length > 0;
+        checks.push({
+            nome: 'custo e provider',
+            nivel: bloqueia ? 'fail' : soAssinatura && pagas.length > 0 ? 'warn' : 'ok',
+            detalhe: bloqueia
+                ? `politica ${politica} violada: ${redirecionam.join(', ')} redireciona o despacho do claude`
+                : pagas.length > 0
+                    ? `politica ${politica}; despacho segue na assinatura local, mas ha credencial paga no ambiente: ${pagas.join(', ')}`
+                    : `politica ${politica}; nenhuma variavel de provider pago ativa`,
+            correcao: bloqueia
+                ? `remova do ambiente: ${redirecionam.join(', ')} (o despacho usa a assinatura Claude local)`
+                : pagas.length > 0
+                    ? `nenhuma acao obrigatoria; nunca despache fase por ${pagas.join(', ')}`
+                    : undefined,
+        });
+        // Bloco B6: o regime de memoria e um CHECK, nao um detalhe do manifesto. Manifesto
+        // que pede `orkmind` e nao consegue liga-lo vira `warn` com a correcao, nunca `fail`:
+        // memoria semantica melhora o produto, e nao e requisito dele.
+        const { estado } = (0, orkmind_1.resolverRegime)(carregado.manifesto, null);
+        checks.push({
+            nome: 'regime de memoria',
+            nivel: estado.efetivo === 'orkmind' ? 'ok' : estado.pedido === 'orkmind' ? 'warn' : 'ok',
+            detalhe: estado.pedido === 'orkmind' && estado.efetivo === 'files'
+                ? `pedido orkmind, efetivo files (${estado.motivo}): ${estado.detalhe}`
+                : estado.efetivo === 'orkmind'
+                    ? `orkmind ativo no tenant "${estado.tenant}" pela variavel ${estado.variavel}`
+                    : 'files (fallback honesto: handoff por arquivos, ponteiro path#ancora)',
+            correcao: estado.pedido === 'orkmind' && estado.efetivo === 'files' ? estado.correcao : undefined,
+        });
+        // Bloco B3: a fila de rate limit e estado do mundo, nao detalhe interno. Uma fase
+        // esperando janela e uma fase que NAO esta rodando, e quem olha o doctor precisa
+        // saber disso antes de concluir que a thread travou.
+        const fila = (0, ratelimit_1.lerFilaDeRetomada)(carregado.raiz);
+        const esperando = fila.filter((p) => p.estado === 'aguardando');
+        const escalados = fila.filter((p) => p.estado === 'escalado');
+        checks.push({
+            nome: 'fila de rate limit',
+            nivel: escalados.length > 0 ? 'warn' : 'ok',
+            detalhe: fila.length === 0
+                ? 'vazia: nenhuma fase morreu por limite de uso neste projeto'
+                : `${esperando.length} aguardando janela, ${escalados.length} escalado(s) para humano` +
+                    (esperando.length > 0 ? `; proxima janela em ${esperando[0].liberaEm}` : ''),
+            correcao: escalados.length > 0
+                ? `pedido escalado alem do limite de retry.max_tentativas: ork retry list e ork gate approve`
+                : esperando.length > 0
+                    ? 'ork retry resume retoma o que ja liberou'
+                    : undefined,
+        });
+        const dirEstadoProjeto = path.join(carregado.raiz, manifest_1.DIR_ESTADO);
+        const threads = path.join(dirEstadoProjeto, 'threads');
+        const qtd = fs.existsSync(threads)
+            ? fs.readdirSync(threads, { withFileTypes: true }).filter((e) => e.isDirectory()).length
+            : 0;
+        checks.push({
+            nome: 'estado do projeto',
+            nivel: fs.existsSync(dirEstadoProjeto) ? 'ok' : 'warn',
+            detalhe: fs.existsSync(dirEstadoProjeto)
+                ? `${dirEstadoProjeto} (${qtd} thread(s))`
+                : `${dirEstadoProjeto} ausente`,
+            correcao: fs.existsSync(dirEstadoProjeto) ? undefined : 'ork init cria o diretorio de estado',
+        });
+        if (claude) {
+            const sessoes = adapter.listarSessoes(carregado.raiz);
+            checks.push({
+                nome: 'sessoes vivas do projeto',
+                nivel: 'ok',
+                detalhe: sessoes.length === 0
+                    ? 'nenhuma sessao ativa sob a raiz do projeto'
+                    : sessoes.map((s) => `${s.name ?? s.sessionId.slice(0, 8)} (${s.state ?? s.status ?? '?'})`).join(', '),
+            });
+        }
+    }
+    return checks;
+}
+/** Texto do relatorio, com o resumo "o que vale nesta maquina agora". */
+function relatorio(checks) {
+    const linhas = [];
+    linhas.push('ork doctor: o que vale nesta maquina agora');
+    linhas.push('');
+    const largura = Math.max(...checks.map((c) => c.nome.length));
+    for (const c of checks) {
+        linhas.push(`  ${(0, util_1.simbolo)(c.nivel)} ${c.nome.padEnd(largura)}  ${c.detalhe}`);
+        if (c.nivel !== 'ok' && c.correcao) {
+            linhas.push(`         ${' '.repeat(largura)}  correcao: ${c.correcao}`);
+        }
+    }
+    const falhas = checks.filter((c) => c.nivel === 'fail').length;
+    const avisos = checks.filter((c) => c.nivel === 'warn').length;
+    linhas.push('');
+    linhas.push(falhas > 0
+        ? `Veredito: BLOQUEADO (${falhas} fail, ${avisos} warn). Corrija os itens acima antes de despachar fase.`
+        : `Veredito: PRONTO (${avisos} warn). Despacho de fase liberado por \`ork phase run\`.`);
+    return linhas.join('\n');
+}
+/** Executa o doctor e devolve o codigo de saida (0 = pronto). */
+function doctor(dirInicial = process.cwd()) {
+    const checks = checar(dirInicial);
+    const falhas = checks.filter((c) => c.nivel === 'fail').length;
+    return { texto: relatorio(checks), codigo: falhas > 0 ? 1 : 0 };
+}