@orkastery/cli 0.4.3 → 0.5.1

package/dist/docs.js

@@ -35,6 +35,8 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LIMITE_DO_PARAGRAFO = exports.LIMITE_DA_FRASE = exports.CATEGORIAS = exports.DIMENSOES = exports.ESTADOS_DA_ESPECIFICACAO = exports.DIR_PADROES = exports.DIR_ROADMAP = exports.DIR_PRODUTO = void 0;
 exports.separarFrontmatter = separarFrontmatter;
+exports.ehPaginaDeDocs = ehPaginaDeDocs;
+exports.documentoDeTexto = documentoDeTexto;
 exports.carregarDocs = carregarDocs;
 exports.resolverBase = resolverBase;
 exports.comandosDaAjuda = comandosDaAjuda;
@@ -44,6 +46,8 @@ exports.renderizarEstado = renderizarEstado;
 exports.textoDaVerificacao = textoDaVerificacao;
 exports.escreverYaml = escreverYaml;
 exports.mergeDaThread = mergeDaThread;
+exports.mergesDaThreadNoGit = mergesDaThreadNoGit;
+exports.escopoPadraoDoSync = escopoPadraoDoSync;
 exports.sincronizarDocs = sincronizarDocs;
 exports.tabelaDoRoadmap = tabelaDoRoadmap;
 exports.tabelaDoProduto = tabelaDoProduto;
@@ -136,38 +140,49 @@ function separarFrontmatter(texto) {
         return { bruto: null, corpo: t };
     return { bruto: t.slice(4, fim + 1), corpo: t.slice(fim + 5) };
 }
+/** `_modelo-*.md` e `README.md` sao modelo e indice, nao paginas de entidade. */
+function ehPaginaDeDocs(nome) {
+    return nome.endsWith('.md') && !nome.startsWith('_') && nome !== 'README.md';
+}
 function paginas(raiz, dir) {
     const abs = path.join(raiz, dir);
     if (!fs.existsSync(abs))
         return [];
-    // `_modelo-*.md` e `README.md` sao modelo e indice, nao paginas de entidade.
     return fs.readdirSync(abs)
-        .filter((n) => n.endsWith('.md') && !n.startsWith('_') && n !== 'README.md')
+        .filter(ehPaginaDeDocs)
         .sort()
         .map((n) => `${dir}/${n}`);
 }
+/**
+ * RM-054: uma pagina a partir do texto, venha ele do disco, de um blob do git ou da forja. O
+ * achado e o mesmo que a leitura do disco daria.
+ */
+function documentoDeTexto(arquivo, texto) {
+    const { bruto, corpo } = separarFrontmatter(texto);
+    if (bruto === null) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.ausente', 'página sem frontmatter YAML', 'comece o arquivo com as chaves do modelo entre duas linhas ---') };
+    }
+    let dados;
+    try {
+        dados = (0, yaml_1.lerYaml)(bruto);
+    }
+    catch (e) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.invalido', `frontmatter inválido: ${e.message}`) };
+    }
+    if (!ehMapa(dados)) {
+        return { achado: erro(arquivo, undefined, 'docs.frontmatter.invalido', 'o frontmatter precisa ser um mapa de chaves') };
+    }
+    return { doc: { arquivo, tipo: dados.tipo, id: String(dados.id ?? ''), dados, corpo } };
+}
 function carregarDocs(raiz) {
     const docs = [];
     const achados = [];
     for (const arquivo of [...paginas(raiz, exports.DIR_PRODUTO), ...paginas(raiz, exports.DIR_ROADMAP)]) {
-        const { bruto, corpo } = separarFrontmatter(fs.readFileSync(path.join(raiz, arquivo), 'utf8'));
-        if (bruto === null) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.ausente', 'página sem frontmatter YAML', 'comece o arquivo com as chaves do modelo entre duas linhas ---'));
-            continue;
-        }
-        let dados;
-        try {
-            dados = (0, yaml_1.lerYaml)(bruto);
-        }
-        catch (e) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.invalido', `frontmatter inválido: ${e.message}`));
-            continue;
-        }
-        if (!ehMapa(dados)) {
-            achados.push(erro(arquivo, undefined, 'docs.frontmatter.invalido', 'o frontmatter precisa ser um mapa de chaves'));
-            continue;
-        }
-        docs.push({ arquivo, tipo: dados.tipo, id: String(dados.id ?? ''), dados, corpo });
+        const lido = documentoDeTexto(arquivo, fs.readFileSync(path.join(raiz, arquivo), 'utf8'));
+        if ('doc' in lido)
+            docs.push(lido.doc);
+        else
+            achados.push(lido.achado);
     }
     return { docs, achados };
 }
@@ -248,9 +263,12 @@ function verificarDocs(raiz, opcoes = {}) {
         verificarFontes(raiz, d, comandos, achados);
         if (d.tipo === 'roadmap') {
             verificarEstadoDoRoadmap(raiz, d, base, achados);
+            if (base)
+                verificarMergeDaThread(raiz, d, base, achados, opcoes.pr === true);
             verificarTabelasDeEstado(d, achados);
         }
     }
+    verificarIndices(raiz, docs, achados, opcoes.pr === true);
     return { docs, achados };
 }
 function verificarChaves(d, achados) {
@@ -550,6 +568,57 @@ function verificarEstadoDoRoadmap(raiz, d, base, achados) {
         }
     }
 }
+/**
+ * RM-037 (fatia 3, defeito 1): o outro sentido da paridade com o git. Depois do merge do PR, o
+ * frontmatter da RM-049 (#26) e da RM-051 (#33) seguiu em "Branch criada", e o verificador dizia OK:
+ * ele so conferia que `Mesclado` tem o commit na base. O merge desta fabrica e pelo GitHub, sem o
+ * `ork ship` no caminho, entao a prova mora aqui, no job que o CI obrigatorio roda. A regra usa o
+ * mesmo `ship(<thread>)` do `sincronizarDocs`: tudo o que ela acusa o `sincronizar` corrige.
+ */
+function verificarMergeDaThread(raiz, d, base, achados, pr = false) {
+    const sdlc = ehMapa(d.dados.sdlc) ? d.dados.sdlc : null;
+    const thread = sdlc && typeof sdlc.thread === 'string' ? sdlc.thread.trim() : '';
+    if (!thread)
+        return;
+    const merges = mergesDaThreadNoGit(raiz, thread, base);
+    if (merges.length === 0)
+        return;
+    const codigo = String((ehMapa(d.dados.estado) ? d.dados.estado.codigo : null) ?? '');
+    if (codigo === 'Mesclado')
+        return;
+    achados.push((pr ? aviso : erro)(d.arquivo, d.id, 'docs.paridade.merge', `a thread ${thread} entrou na ${base} pelo merge ${merges[0].slice(0, 7)} (ship(${thread})), e o estado.codigo diz "${codigo || 'vazio'}"` +
+        (pr ? ' (no PR, aviso: o push da main reprova)' : ''), `abra um PR de docs sobre a ${base} atualizada com ork docs sincronizar --escrever --so ${d.id} (o item e os índices); ` +
+        `se o item tem outra fatia em curso, aponte sdlc.thread para a thread dela`));
+}
+/** Os indices gerados (`docs/roadmap/README.md`, `docs/produto/README.md`) e o que o frontmatter diz. */
+const INDICES_GERADOS = [
+    [`${exports.DIR_ROADMAP}/README.md`, (docs) => tabelaDoRoadmap(docs)],
+    [`${exports.DIR_PRODUTO}/README.md`, (docs) => tabelaDoProduto(docs)],
+];
+/**
+ * RM-037 (fatia 3, defeito 1): o indice e uma vista do frontmatter, como as tabelas do corpo, e mentia
+ * do mesmo jeito: sem a RM-051 e com a RM-031 de antes. Divergente reprova; vazio (o modelo recem-copiado
+ * pelo `ork docs init`) so avisa; sem os marcadores, nao ha indice gerado para conferir.
+ */
+function verificarIndices(raiz, docs, achados, pr = false) {
+    for (const [arquivo, gerar] of INDICES_GERADOS) {
+        const abs = path.join(raiz, arquivo);
+        if (!fs.existsSync(abs))
+            continue;
+        // Checkout com CRLF (Windows com core.autocrlf) nao e divergencia: as paginas tambem normalizam.
+        const atual = blocoEntre(fs.readFileSync(abs, 'utf8').replace(/\r\n/g, '\n'), INICIO, FIM);
+        if (atual === null)
+            continue;
+        if (atual === '') {
+            if (docs.length > 0) {
+                achados.push(aviso(arquivo, undefined, 'docs.paridade.indice', 'o índice ainda não foi gerado', 'rode ork docs sincronizar --escrever'));
+            }
+        }
+        else if (atual !== gerar(docs)) {
+            achados.push((pr ? aviso : erro)(arquivo, undefined, 'docs.paridade.indice', `o índice diverge do frontmatter das páginas${pr ? ' (no PR, aviso: o push da main reprova)' : ''}`, 'o índice é gerado do frontmatter: rode ork docs sincronizar --escrever e commite o índice'));
+        }
+    }
+}
 // --------------------------------------------------------------------------------------------
 // Saida para humano (TDAH) e para agente
 function textoDaVerificacao(docs, achados) {
@@ -652,24 +721,65 @@ function mergeDaThread(raiz, thread, base) {
             return { sha: String(ship.mergeSha).slice(0, 7), fonte: 'ledger ship_done' };
     }
     catch { /* thread sem estado nesta maquina: cai para o git */ }
-    // Sem `-n 1`: o git corta antes de inverter, e `--reverse -n 1` devolveria o mais recente.
-    const log = git(raiz, ['log', base, '--reverse', '--format=%H', '--fixed-strings', `--grep=ship(${thread})`]);
-    const primeiro = log.ok ? log.saida.split('\n')[0] : '';
+    const primeiro = mergesDaThreadNoGit(raiz, thread, base)[0];
     if (primeiro)
         return { sha: primeiro.slice(0, 7), fonte: `git log ${base}` };
     return null;
 }
+/**
+ * Os commits `ship(<thread>)` da base, do mais velho ao mais novo, so pelo git (o CI nao tem ledger).
+ * RM-037 (fatia 3): um lugar so para o `sincronizarDocs` e o `verificarDocs` acharem o mesmo merge.
+ */
+function mergesDaThreadNoGit(raiz, thread, base) {
+    // Sem `-n 1`: o git corta antes de inverter, e `--reverse -n 1` devolveria o mais recente.
+    // GO-FIX 2 (achado 4 do CHECK): so a linha de primeiro pai da base e o assunto que COMECA com
+    // `ship(<thread>)`, como no `mergeDaEntrega`. Commit que cita o merge no corpo, ou o Revert dele, nao e merge.
+    const log = git(raiz, ['log', base, '--first-parent', '--reverse', '--format=%H%x09%s', '--fixed-strings', `--grep=ship(${thread})`]);
+    if (!log.ok)
+        return [];
+    return log.saida.split('\n').map((l) => l.split('\t'))
+        .filter(([sha, assunto]) => !!sha && typeof assunto === 'string' && assunto.startsWith(`ship(${thread})`))
+        .map(([sha]) => sha);
+}
 function temBranch(raiz, thread) {
     const r = git(raiz, ['for-each-ref', '--format=%(refname:short)', `refs/heads/ork/${thread}-*`, `refs/remotes/origin/ork/${thread}-*`]);
     return r.ok && r.saida.length > 0;
 }
 const ORDEM_DO_CODIGO = exports.DIMENSOES.codigo;
+/**
+ * RM-037 (rm037noite, defeito 5): o escopo padrao do `ork docs sincronizar`. Na worktree de uma thread
+ * com item do roadmap, so o item dela: da worktree da ork-rm037noite, o sincronizar gravava RM-025,
+ * 026, 031, 038, 048, 049, 050 e 054, e cada PR conflitava com as outras. Fora de worktree de thread
+ * (a raiz, onde o condutor sincroniza depois do merge), todo item, como antes.
+ */
+function escopoPadraoDoSync(raiz) {
+    const real = (p) => { try {
+        return fs.realpathSync(p);
+    }
+    catch {
+        return path.resolve(p);
+    } };
+    const aqui = real(raiz);
+    for (const id of (0, thread_1.listarIds)(raiz)) {
+        let t;
+        try {
+            t = (0, thread_1.lerThread)(raiz, id);
+        }
+        catch {
+            continue;
+        }
+        if (t.worktree && real(t.worktree) === aqui)
+            return { itens: t.roadmap ? [t.roadmap] : null, thread: t.id };
+    }
+    return { itens: null, thread: null };
+}
 function sincronizarDocs(raiz, opcoes = {}) {
     const base = resolverBase(raiz, opcoes.baseBranch) ?? (opcoes.baseBranch ?? 'main');
     const agora = opcoes.agora ?? (() => isoComFusoLocal(new Date()));
     const { docs } = carregarDocs(raiz);
     const mudancas = [];
-    for (const d of docs.filter((x) => x.tipo === 'roadmap')) {
+    const noEscopo = (d) => !opcoes.itens || opcoes.itens.includes(d.id);
+    for (const d of docs.filter((x) => x.tipo === 'roadmap' && noEscopo(x))) {
         const sdlc = ehMapa(d.dados.sdlc) ? d.dados.sdlc : null;
         const thread = sdlc && typeof sdlc.thread === 'string' ? sdlc.thread : null;
         if (!thread)
@@ -715,7 +825,7 @@ function sincronizarDocs(raiz, opcoes = {}) {
     }
     // As tabelas de estado do corpo sao vistas do frontmatter: regeradas em todo item de roadmap,
     // inclusive quando a pessoa mudou o frontmatter a mao (ciclo, deploy, exposicao...).
-    for (const d of docs.filter((x) => x.tipo === 'roadmap')) {
+    for (const d of docs.filter((x) => x.tipo === 'roadmap' && noEscopo(x))) {
         const novo = substituirBloco(substituirBloco(d.corpo, RELANCE_INI, RELANCE_FIM, renderizarRelance(d)), ESTADO_INI, ESTADO_FIM, renderizarEstado(d));
         if (novo !== d.corpo) {
             if (!mudancas.some((m) => m.id === d.id)) {

package/dist/doctor.js

@@ -39,8 +39,14 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.TETO_DO_DONO_DO_GIT = void 0;
 exports.checarContas = checarContas;
+exports.checarChaveDeEmbedding = checarChaveDeEmbedding;
+exports.checarDonoDoGit = checarDonoDoGit;
 exports.checarOnboarding = checarOnboarding;
+exports.blocosDoRuntime = blocosDoRuntime;
+exports.checarRuntimeClaude = checarRuntimeClaude;
+exports.checarDespachoPeloCodex = checarDespachoPeloCodex;
 exports.checar = checar;
 exports.relatorio = relatorio;
 exports.doctor = doctor;
@@ -62,6 +68,7 @@ const project_state_1 = require("./project-state");
 const runtime_ambiente_1 = require("./runtime-ambiente");
 const runtime_profiles_1 = require("./runtime-profiles");
 const preflight_1 = require("./preflight");
+const setup_1 = require("./setup");
 /**
  * I-33 (D7): check "contas por runtime". Cada perfil ativo tem o login conferido pelo proprio
  * CLI com o env dele (`claude auth status`, `codex login status`); o doctor so le e relata, sem
@@ -116,6 +123,112 @@ const ENVS_QUE_REDIRECIONAM = [
 function versaoNode() {
     return Number(process.versions.node.split('.')[0]);
 }
+/**
+ * I-38 (T7): a chave de embedding aparece pelo NOME, nunca pelo valor. Ausente e aviso (a busca
+ * cai para o fallback local ou para FTS e o regime segue); nome de provider pago e falha, porque a
+ * entrada do `ork` apagaria a variavel sob `subscription-only` e o preflight reprovaria o codex.
+ */
+function checarChaveDeEmbedding(carregado, env = process.env) {
+    const nome = 'chave de embedding';
+    const config = (0, manifest_1.configDeEmbedding)(carregado.manifesto);
+    if (config.provider === 'none')
+        return { nome, nivel: 'ok', detalhe: 'memory.embedding com provider none: busca por significado desligada' };
+    const variavel = config.api_key_env;
+    if (runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(variavel)) {
+        return { nome, nivel: 'fail', detalhe: `memory.embedding.api_key_env declara ${variavel}, nome da lista de provider pago`,
+            correcao: 'use uma chave dedicada ao Orkastery com nome proprio, por exemplo ORKASTERY_EMBEDDING_API_KEY' };
+    }
+    if (!variavel) {
+        return { nome, nivel: 'fail', detalhe: `memory.embedding com provider ${config.provider} sem api_key_env`,
+            correcao: 'declare em memory.embedding.api_key_env o NOME da variavel com a chave dedicada' };
+    }
+    const valor = (env[variavel] ?? '').trim();
+    const dsn = carregado.manifesto.memory.database_url_env ? (env[carregado.manifesto.memory.database_url_env] ?? '') : '';
+    if (valor !== '' && !(0, orkmind_1.chaveDeEmbeddingAceita)(valor, dsn)) {
+        return { nome, nivel: 'fail', detalhe: `${variavel} tem valor recusado: parece URL, DSN ou texto com espaco (valor nunca impresso)`,
+            correcao: `confira se ${variavel} guarda a chave dedicada, e nao outra credencial` };
+    }
+    if (valor !== '') {
+        return { nome, nivel: 'ok', detalhe: `${variavel} presente no ambiente (valor nunca impresso); ${config.provider} ${config.model}` };
+    }
+    return { nome, nivel: 'warn', detalhe: `${variavel} ausente do ambiente: a busca por significado usa o fallback local ou cai para FTS; o regime nao muda`,
+        correcao: `exporte ${variavel} com a chave dedicada ao Orkastery (com limite de credito no painel do provider)` };
+}
+/** Acima disso a conferencia do dono do `.git` fica parcial (aviso), para o doctor nao pesar. */
+exports.TETO_DO_DONO_DO_GIT = 200_000;
+/**
+ * RM-037 (fatia 3, defeito 7): git rodado como root no repositorio do dono deixa objeto, pasta e
+ * `FETCH_HEAD` com outro dono, e o git do dono deixa de gravar neles: o fetch travou em 29/09 e em
+ * 01/10. O dono do repositorio e o dono do diretorio comum do git. O check acusa com a contagem, ate
+ * tres exemplos e o `chown` exato; o doctor nunca roda nada. Fora de repositorio git, `null`.
+ */
+function checarDonoDoGit(dirInicial, opcoes = {}) {
+    const nome = 'dono do .git';
+    const comum = (0, util_1.exec)('git', ['rev-parse', '--git-common-dir'], dirInicial);
+    if (!comum.ok || !comum.stdout.trim())
+        return null;
+    const dirComum = path.resolve(dirInicial, comum.stdout.trim());
+    const lstat = opcoes.lstat ?? ((p) => fs.lstatSync(p));
+    let raiz;
+    try {
+        raiz = lstat(dirComum);
+    }
+    catch {
+        return null;
+    }
+    const teto = opcoes.teto ?? exports.TETO_DO_DONO_DO_GIT;
+    const relativo = (f) => path.relative(path.dirname(dirComum), f);
+    // A correcao sai pronta para copiar: caminho com caractere fora do conjunto seguro vai entre aspas simples.
+    const noShell = (s) => /^[A-Za-z0-9._/-]+$/.test(s) ? s : `'${s.replace(/'/g, "'\\''")}'`;
+    const estranhos = [], uids = new Set();
+    let total = 0, vistos = 0, parcial = false;
+    const pilha = [dirComum];
+    while (pilha.length > 0 && !parcial) {
+        const atual = pilha.pop();
+        let nomes;
+        // Pasta que o dono nao consegue listar ja aparece pelo dono dela, na entrada de cima.
+        try {
+            nomes = fs.readdirSync(atual);
+        }
+        catch {
+            continue;
+        }
+        for (const n of nomes) {
+            if (++vistos > teto) {
+                parcial = true;
+                break;
+            }
+            const f = path.join(atual, n);
+            let st;
+            try {
+                st = lstat(f);
+            }
+            catch {
+                continue;
+            }
+            if (st.uid !== raiz.uid) {
+                total++;
+                uids.add(st.uid);
+                if (estranhos.length < 3)
+                    estranhos.push(relativo(f));
+            }
+            if (st.isDirectory())
+                pilha.push(f);
+        }
+    }
+    if (total > 0) {
+        return { nome, nivel: 'fail',
+            detalhe: `${total} entrada(s) de ${relativo(dirComum)} com outro dono (uid ${[...uids].sort((a, b) => a - b).join(', ')}; o do ` +
+                `repositorio e ${raiz.uid}): ${estranhos.join(', ')}${total > estranhos.length ? ', ...' : ''}; o git do dono nao grava nelas, ` +
+                `e o fetch e o commit falham${parcial ? ` (conferencia parcial: mais de ${teto} entradas)` : ''}`,
+            correcao: `sudo chown -R ${raiz.uid}:${raiz.gid} ${noShell(dirComum)} (o ork nao roda isso sozinho)` };
+    }
+    if (parcial) {
+        return { nome, nivel: 'warn', detalhe: `mais de ${teto} entradas em ${relativo(dirComum)}: conferencia parcial, sem outro dono ate aqui`,
+            correcao: `confira o resto com: find ${noShell(dirComum)} -not -uid ${raiz.uid}` };
+    }
+    return { nome, nivel: 'ok', detalhe: `${vistos} entradas de ${relativo(dirComum)} com o dono do repositorio (uid ${raiz.uid})` };
+}
 /** Checks locais; ler a entrevista não abre driver, banco, runtime ou rede. */
 function checarOnboarding(carregado) {
     const estado = (0, onboarding_1.lerOnboarding)(carregado.raiz);
@@ -131,9 +244,15 @@ function checarOnboarding(carregado) {
         checks.push({ nome: 'onboarding memoria', nivel: 'warn', detalhe: `entrevista escolheu ${modo}; manifesto declara ${carregado.manifesto.memory.mode}`,
             correcao: `revise memory.mode: ${modo} em orkastery.yaml; a entrevista não altera o manifesto` });
     }
-    // I-35: o fuso respondido na etapa maestro orienta owner.timezone, sem editar o manifesto.
+    // I-35: o fuso respondido na etapa maestro orienta owner.timezone, sem editar o manifesto. Com
+    // `owner.timezone` na mesma resposta (gravado no manifesto pelo `onboarding set`), vale ele: no
+    // ensaio da 0.5.0, o `fuso` legado da resposta anterior mandava desfazer a escolha explicita.
     const maestro = estado.etapas.maestro?.conteudo;
-    const fusoDaEntrevista = maestro && typeof maestro === 'object' && !Array.isArray(maestro) ? (0, horario_1.normalizarFuso)(maestro.fuso) : undefined;
+    const owner = maestro && typeof maestro === 'object' && !Array.isArray(maestro) ? maestro.owner : undefined;
+    const fusoDoOwner = owner && typeof owner === 'object' && !Array.isArray(owner) ? owner.timezone : undefined;
+    // Owner invalido (so por edicao a mao: o `onboarding set` recusa) nao cala o fuso legado.
+    const fusoDaEntrevista = maestro && typeof maestro === 'object' && !Array.isArray(maestro)
+        ? (0, horario_1.normalizarFuso)(fusoDoOwner) ?? (0, horario_1.normalizarFuso)(maestro.fuso) : undefined;
     if (fusoDaEntrevista && fusoDaEntrevista !== carregado.manifesto.owner?.timezone) {
         checks.push({ nome: 'onboarding fuso', nivel: 'warn',
             detalhe: `entrevista informou ${fusoDaEntrevista}; manifesto declara ${carregado.manifesto.owner?.timezone ?? `${horario_1.CHAVE_DO_FUSO} ausente`}`,
@@ -141,6 +260,97 @@ function checarOnboarding(carregado) {
     }
     return checks;
 }
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P1): por qual runtime cada bloco dos modos de
+ * `conduction.allowed_modes` despacha, pelo mesmo criterio do despacho sem opcao de CLI
+ * (`resolverDespacho`: o bloco do setup vence `runtime.adapter`). Quem passou os blocos para o
+ * Codex nao precisa do `claude`. Setup ilegivel devolve `null`: quem chama fica no lado seguro.
+ */
+function blocosDoRuntime(carregado, runtime) {
+    const { manifesto } = carregado;
+    const r = { principal: [], fallback: [] };
+    try {
+        const setup = (0, setup_1.lerSetup)(carregado.raiz);
+        for (const modo of manifesto.conduction.allowed_modes) {
+            modos_1.MODOS[modo].blocos.forEach((b, i) => {
+                const doBloco = (0, setup_1.configDoBloco)(setup, modo, b.fases[0]);
+                const bloco = { tag: modos_1.MODOS[modo].tag, bloco: i + 1 };
+                if ((doBloco?.runtime ?? manifesto.runtime.adapter) === runtime)
+                    r.principal.push(bloco);
+                else if (doBloco?.fallback?.some((f) => f.split(':')[0] === runtime))
+                    r.fallback.push(bloco);
+            });
+        }
+    }
+    catch {
+        return null;
+    }
+    return r;
+}
+/** `#Classic 1, 2; #Auto 1`: os blocos agrupados por modo, na ordem dos modos permitidos. */
+function textoDosBlocos(blocos) {
+    const porModo = new Map();
+    for (const b of blocos)
+        porModo.set(b.tag, [...(porModo.get(b.tag) ?? []), b.bloco]);
+    return [...porModo].map(([tag, numeros]) => `${tag} ${numeros.join(', ')}`).join('; ');
+}
+/**
+ * Fatia 2 do ensaio da 0.5.0 (P1): o `claude` so e obrigatorio quando algum bloco de modo permitido
+ * despacha por ele. Sem manifesto, com manifesto invalido ou com setup ilegivel vale o padrao (todo
+ * bloco no claude-bg), e a falta reprova como antes.
+ */
+function checarRuntimeClaude(carregado, claude, versao) {
+    const nome = 'runtime claude-bg';
+    if (claude)
+        return { nome, nivel: 'ok', detalhe: `${claude} (${versao ?? 'versao desconhecida'})` };
+    const blocos = carregado && carregado.erros.length === 0 ? blocosDoRuntime(carregado, 'claude-bg') : null;
+    if (blocos && blocos.principal.length === 0) {
+        // CHECK, rodada 1 (S6): as fases nao precisam dele, mas o `ork audit run` despacha sempre pelo claude-bg.
+        return { nome, nivel: 'warn',
+            detalhe: 'binario `claude` fora do PATH (opcional para as fases: nenhum bloco dos modos permitidos despacha pelo claude-bg' +
+                (blocos.fallback.length
+                    ? `; o fallback de ${blocos.fallback.length} bloco(s) cai nele e falharia: ${textoDosBlocos(blocos.fallback)}` : '') +
+                '; o ork audit run ainda despacha por ele)',
+            correcao: 'para despachar pelo claude-bg (e rodar ork audit run), instale o Claude Code e garanta `claude` no PATH' };
+    }
+    return { nome, nivel: 'fail',
+        detalhe: 'binario `claude` fora do PATH' + (blocos
+            ? `; ${blocos.principal.length} bloco(s) dos modos permitidos despacham por ele (${textoDosBlocos(blocos.principal)})` : ''),
+        correcao: 'instale o Claude Code e garanta `claude` no PATH; so com o Codex, passe cada bloco para ele ' +
+            '(ork setup <modo> --bloco N --runtime codex --model <modelo>) ou tire o modo de conduction.allowed_modes ' +
+            '(mantenha o conduction.default_mode entre os permitidos)' };
+}
+/**
+ * O despacho pelo Codex quando o projeto o elege: por `runtime.adapter: codex`, como antes, ou, desde
+ * a fatia 2 do ensaio da 0.5.0 (P1), por bloco de modo permitido. A falta do `codex`, ou um sandbox
+ * que nao executa, deixa de ser aviso: e exatamente o que bloquearia a fase. Sem nenhum dos dois, o
+ * check nao sai.
+ */
+function checarDespachoPeloCodex(carregado, codex, sonda) {
+    const pelaAdapter = carregado.manifesto.runtime.adapter === 'codex';
+    const blocos = blocosDoRuntime(carregado, 'codex')?.principal ?? [];
+    if (!pelaAdapter && blocos.length === 0)
+        return null;
+    const origem = [pelaAdapter ? 'runtime.adapter: codex' : '',
+        blocos.length ? `${blocos.length} bloco(s) dos modos permitidos no codex (${textoDosBlocos(blocos)})` : '']
+        .filter(Boolean).join(' e ');
+    const sandboxConfigurado = carregado.manifesto.runtime.sandbox;
+    const sandboxQuebrado = sonda !== null && !sonda.ok && sandboxConfigurado !== 'danger-full-access';
+    return {
+        nome: 'despacho pelo codex',
+        nivel: !codex ? 'fail' : sandboxQuebrado ? 'fail' : 'ok',
+        detalhe: !codex
+            ? `${origem}, mas o binario \`codex\` esta fora do PATH`
+            : sandboxQuebrado
+                ? `${origem} com sandbox "${sandboxConfigurado}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`
+                : `${origem} com sandbox "${sandboxConfigurado}"`,
+        correcao: !codex
+            ? 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)'
+            : sandboxQuebrado
+                ? 'instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco'
+                : undefined,
+    };
+}
 /** Roda todos os checks a partir do diretorio informado. */
 function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente_1.nomesDeProviderAtivos)()) {
     const checks = [];
@@ -160,31 +370,43 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
     });
     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);
+    // Ensaio da 0.5.0: sem commit, o `rev-parse --abbrev-ref` respondia "HEAD"; a branch vem do
+    // `symbolic-ref`, e a falta de commit fica dita.
+    const semCommit = dentroDeRepo && !(0, util_1.exec)('git', ['rev-parse', '--verify', '--quiet', 'HEAD'], dirInicial).ok;
+    const branch = dentroDeRepo ? (0, util_1.branchDoHead)(dirInicial) ?? (0, util_1.exec)('git', ['rev-parse', '--abbrev-ref', 'HEAD'], dirInicial).stdout.trim() : '';
     checks.push({
         nome: 'repositorio',
         nivel: dentroDeRepo ? 'ok' : 'fail',
-        detalhe: dentroDeRepo ? `branch ${branch.stdout.trim()}` : 'fora de um repositorio git',
+        detalhe: dentroDeRepo ? `branch ${branch}${semCommit ? ' (sem commit)' : ''}` : 'fora de um repositorio git',
         correcao: dentroDeRepo ? undefined : 'rode o ork dentro de um repositorio git',
     });
+    if (dentroDeRepo) {
+        const dono = checarDonoDoGit(dirInicial);
+        if (dono)
+            checks.push(dono);
+    }
+    // Fatia 2 do ensaio da 0.5.0 (P1): o manifesto e lido antes dos runtimes, porque e o setup dos
+    // modos permitidos que diz se o `claude` e obrigatorio; a ordem das linhas do relatorio nao muda.
+    const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     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',
-    });
+    checks.push(checarRuntimeClaude(carregado, claude, v));
     // Segundo runtime homologado. Ausente e `warn`, nao `fail`: o claude-bg segue sendo o
     // padrao, e um projeto que nunca pediu codex nao pode ficar bloqueado por ele.
     const codex = codexAdapter.disponivel();
     const codexVersao = codex ? codexAdapter.versao() : null;
+    // CHECK, rodada 1 (S6): com o projeto despachando pelo codex, a falta dele nao e "opcional"; quem
+    // reprova e o check `despacho pelo codex`, mais abaixo.
+    const usaCodex = !!carregado && carregado.erros.length === 0 && (carregado.manifesto.runtime.adapter === 'codex' ||
+        (blocosDoRuntime(carregado, 'codex')?.principal.length ?? 0) > 0);
     checks.push({
         nome: 'runtime codex',
         nivel: codex ? 'ok' : 'warn',
         detalhe: codex
             ? `${codex} (${codexVersao ?? 'versao desconhecida'})`
-            : 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
+            : usaCodex
+                ? 'binario `codex` fora do PATH (o projeto despacha por ele: veja despacho pelo codex)'
+                : 'binario `codex` fora do PATH (opcional: claude-bg e o runtime padrao)',
         correcao: codex
             ? undefined
             : 'para despachar pelo codex, instale o Codex CLI e autentique com `codex login`',
@@ -206,7 +428,6 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                     'nesta maquina) ou declare runtime.sandbox: danger-full-access ciente do risco',
         });
     }
-    const carregado = (0, manifest_1.carregarManifesto)(dirInicial);
     if (!carregado) {
         checks.push({
             nome: 'manifesto',
@@ -253,26 +474,11 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                 : `${fuso.fuso} (fuso do sistema; ${horario_1.CHAVE_DO_FUSO} nao configurado)`),
             correcao: fuso.aviso ? `corrija ${horario_1.CHAVE_DO_FUSO} com um nome IANA` : undefined,
         });
-        // Quando o manifesto ELEGE o codex como runtime de despacho, a ausencia dele (ou um
+        // Quando o manifesto ou um bloco de modo permitido ELEGE o codex, a ausencia dele (ou um
         // sandbox que nao executa) deixa de ser aviso: e exatamente o que bloquearia a fase.
-        if (carregado.manifesto.runtime.adapter === 'codex') {
-            const sandboxConfigurado = carregado.manifesto.runtime.sandbox;
-            const sandboxQuebrado = sondaDoCodex !== null && !sondaDoCodex.ok && sandboxConfigurado !== 'danger-full-access';
-            checks.push({
-                nome: 'despacho pelo codex',
-                nivel: !codex ? 'fail' : sandboxQuebrado ? 'fail' : 'ok',
-                detalhe: !codex
-                    ? 'runtime.adapter: codex, mas o binario `codex` esta fora do PATH'
-                    : sandboxQuebrado
-                        ? `runtime.adapter: codex com sandbox "${sandboxConfigurado}", mas o sandbox nao executa nesta maquina (o agente narraria sucesso sem rodar nada)`
-                        : `runtime.adapter: codex com sandbox "${sandboxConfigurado}"`,
-                correcao: !codex
-                    ? 'instale o Codex CLI e autentique com `codex login` (assinatura, nunca API key)'
-                    : sandboxQuebrado
-                        ? 'instale o bubblewrap do sistema, ou declare runtime.sandbox: danger-full-access ciente do risco'
-                        : undefined,
-            });
-        }
+        const despachoPeloCodex = checarDespachoPeloCodex(carregado, codex, sondaDoCodex);
+        if (despachoPeloCodex)
+            checks.push(despachoPeloCodex);
         const politica = carregado.manifesto.runtime.provider_policy;
         const soAssinatura = politica === 'subscription-only';
         const redirecionam = ENVS_QUE_REDIRECIONAM.filter(e => nomesHerdados.includes(e));
@@ -315,6 +521,7 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
                     : 'files (fallback honesto: handoff por arquivos, ponteiro path#ancora)',
             correcao: estado.pedido === 'orkmind' && estado.efetivo === 'files' ? estado.correcao : undefined,
         });
+        checks.push(checarChaveDeEmbedding(context.loaded));
         // 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.
@@ -352,12 +559,15 @@ function checar(dirInicial = process.cwd(), nomesHerdados = (0, runtime_ambiente
         checks.push(...(0, preflight_1.sondasDeAmbiente)(carregado.raiz));
         {
             const inventario = (0, sessoes_inventario_1.inventariarSessoes)(carregado.raiz, { global: true, todas: true });
+            // Fatia 2 do ensaio da 0.5.0 (P1): binario ausente e fonte ausente, dita no detalhe.
+            const ausentes = inventario.fontes.filter((f) => f.ausente).map((f) => f.origem);
             checks.push({
                 nome: 'governanca de sessoes',
                 nivel: inventario.ok && inventario.semThread === 0 ? 'ok' : 'warn',
                 detalhe: `${inventario.escopo.usuario}, Claude e Codex, global com histórico: ${inventario.total} sessões; ` +
                     `${inventario.semThread} sem thread; ${inventario.ambiguas} ambíguas; ` +
-                    `inventário ${inventario.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}`,
+                    `inventário ${inventario.ok ? 'válido' : 'INCOMPLETO (zero não comprovado)'}` +
+                    (ausentes.length ? `; fonte ausente: ${ausentes.join(', ')}` : ''),
                 correcao: inventario.ok && inventario.semThread === 0 ? undefined :
                     'ork sessions --global --all --json; adote identidades sem vínculo com ork sessions adopt <id>',
             });