@orkastery/cli 0.4.3 → 0.5.0

package/dist/intelligence-graph-repo.js

@@ -0,0 +1,187 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TENANT_PADRAO = void 0;
+exports.identidadeDaLeitura = identidadeDaLeitura;
+exports.revisaoDaArvore = revisaoDaArvore;
+exports.headsDasArvores = headsDasArvores;
+exports.lerRepositorio = lerRepositorio;
+/**
+ * RM-031 KG2 (D8): leitura do repositorio Git local para o extrator. E a unica borda de E/S do
+ * KG2: lista os arquivos rastreados, le os bytes da arvore de trabalho e fixa a revisao. Nao
+ * executa shell nem texto vindo do repositorio; o Git roda com argumentos fixos. O KG3 usa daqui a
+ * identidade da leitura e a revisao da arvore limpa, sem ler os arquivos.
+ *
+ * Fica fora e declarado: link simbolico, submodulo, arquivo em conflito, arquivo rastreado que
+ * sumiu da arvore, arquivo cujo caminho real sai da raiz e caminho que nao e UTF-8. A revisao so e
+ * o HEAD quando nada rastreado mudou e os bytes lidos sao os blobs do indice (sem filtro do Git).
+ */
+const node_crypto_1 = require("node:crypto");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const yaml_1 = require("./yaml");
+exports.TENANT_PADRAO = 'local';
+const ID_DE_REPOSITORIO = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
+/** Git com argumentos fixos; o fsmonitor do repositorio nao roda (seria comando externo configurado nele). */
+function git(raiz, args) {
+    const r = (0, node_child_process_1.spawnSync)('git', ['-c', 'core.fsmonitor=false', ...args], {
+        cwd: raiz, maxBuffer: 512 * 1024 * 1024, env: { ...process.env, GIT_OPTIONAL_LOCKS: '0' },
+    });
+    return { ok: r.status === 0, saida: r.stdout ?? Buffer.alloc(0) };
+}
+function obrigatorio(raiz, args) {
+    const r = git(raiz, args);
+    if (!r.ok)
+        throw new Error(`extracao.repositorio.git-falhou em git ${args[0]}`);
+    return r.saida;
+}
+const utf8 = (b) => {
+    try {
+        return new TextDecoder('utf-8', { fatal: true }).decode(b);
+    }
+    catch {
+        return null;
+    }
+};
+/** Nome do projeto no `orkastery.yaml`, quando ha um valido na raiz. */
+function nomeDoProjeto(raiz) {
+    const arquivo = path.join(raiz, 'orkastery.yaml');
+    if (!fs.existsSync(arquivo))
+        return null;
+    try {
+        const dados = (0, yaml_1.lerYaml)(fs.readFileSync(arquivo, 'utf8'));
+        const projeto = dados && typeof dados === 'object' && !Array.isArray(dados) ? dados.project : null;
+        const nome = projeto && typeof projeto === 'object' && !Array.isArray(projeto) ? projeto.name : null;
+        return typeof nome === 'string' && ID_DE_REPOSITORIO.test(nome) ? nome : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Repositorio, tenant e ACL da leitura: os informados, ou os padroes (D8). */
+function identidadeDaLeitura(raiz, opcoes = {}) {
+    const repositorio = opcoes.repository_id ?? nomeDoProjeto(raiz);
+    if (!repositorio || !ID_DE_REPOSITORIO.test(repositorio))
+        throw new Error('extracao.repositorio.sem-id');
+    return { repository_id: repositorio, tenant_id: opcoes.tenant_id ?? exports.TENANT_PADRAO, acl_refs: [...(opcoes.acl_refs ?? [`repo:${repositorio}:leitura`])] };
+}
+/**
+ * RM-031 KG3 (D3): o HEAD e se a arvore esta limpa nos rastreados, sem ler arquivo nenhum. O filtro
+ * do Git (eol, LFS) so aparece lendo os bytes: quem indexa confere a revisao do `lerRepositorio`.
+ */
+function revisaoDaArvore(diretorio) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const head = git(raiz, ['rev-parse', '--verify', '-q', 'HEAD']);
+    if (!head.ok)
+        return { raiz, head: null, motivo: 'sem-commit' };
+    const sujo = obrigatorio(raiz, ['status', '--porcelain=v1', '-z', '--untracked-files=no']).length > 0;
+    return { raiz, head: head.saida.toString('utf8').trim(), motivo: sujo ? 'working-tree-modified' : null };
+}
+/**
+ * RM-031 KG3 (CHECK rodada 1, A6): o HEAD de cada arvore do repositorio (a principal e as worktrees),
+ * pelo `git worktree list --porcelain`. O estado do indice e compartilhado entre elas.
+ */
+function headsDasArvores(diretorio) {
+    const saida = obrigatorio(diretorio, ['worktree', 'list', '--porcelain']).toString('utf8');
+    return [...new Set(saida.split('\n').filter((l) => /^HEAD [0-9a-f]{40,64}$/.test(l)).map((l) => l.slice(5)))].sort();
+}
+/** Le o repositorio que contem `diretorio` e devolve a entrada do extrator. */
+function lerRepositorio(diretorio, opcoes = {}) {
+    const raiz = obrigatorio(diretorio, ['rev-parse', '--show-toplevel']).toString('utf8').trim();
+    const { repository_id: repositorio, tenant_id, acl_refs } = identidadeDaLeitura(raiz, opcoes);
+    // `-s` traz modo e estagio: 120000 e link simbolico, 160000 e submodulo, estagio > 0 e conflito.
+    const registros = obrigatorio(raiz, ['ls-files', '-z', '-s', '--full-name']);
+    const porCaminho = new Map(), excluidas = [];
+    let inicio = 0;
+    for (let i = 0; i < registros.length; i++) {
+        if (registros[i] !== 0)
+            continue;
+        const registro = registros.subarray(inicio, i);
+        inicio = i + 1;
+        const tab = registro.indexOf(0x09);
+        if (tab < 0)
+            continue;
+        const [modo, objeto, estagio] = registro.subarray(0, tab).toString('latin1').split(' ');
+        const caminho = utf8(registro.subarray(tab + 1));
+        if (caminho === null) {
+            excluidas.push({ path: registro.subarray(tab + 1).toString('latin1'), motivo: 'caminho-nao-utf8' });
+            continue;
+        }
+        const atual = porCaminho.get(caminho);
+        porCaminho.set(caminho, { modo, objeto, estagios: (atual?.estagios ?? 0) + (estagio === '0' ? 0 : 1) });
+    }
+    const fontes = [], raizReal = fs.realpathSync(raiz);
+    let filtrado = false;
+    for (const [caminho, { modo, objeto, estagios }] of porCaminho) {
+        if (estagios > 0)
+            excluidas.push({ path: caminho, motivo: 'conflito-de-merge' });
+        else if (modo === '120000')
+            excluidas.push({ path: caminho, motivo: 'link-simbolico' });
+        else if (modo === '160000')
+            excluidas.push({ path: caminho, motivo: 'submodulo' });
+        else {
+            const absoluto = path.join(raiz, caminho);
+            const st = fs.lstatSync(absoluto, { throwIfNoEntry: false });
+            if (!st)
+                excluidas.push({ path: caminho, motivo: 'ausente-na-arvore' });
+            else if (!st.isFile())
+                excluidas.push({ path: caminho, motivo: 'nao-e-arquivo' });
+            // Pasta do caminho trocada por link simbolico levaria a leitura para fora do repositorio.
+            else if (!fs.realpathSync(absoluto).startsWith(raizReal + path.sep))
+                excluidas.push({ path: caminho, motivo: 'fora-do-repositorio' });
+            else {
+                const bytes = fs.readFileSync(absoluto);
+                if ((0, node_crypto_1.createHash)('sha1').update(`blob ${bytes.length}\0`).update(bytes).digest('hex') !== objeto)
+                    filtrado = true;
+                fontes.push({ path: caminho, bytes });
+            }
+        }
+    }
+    const head = git(raiz, ['rev-parse', '--verify', '-q', 'HEAD']);
+    const sujo = obrigatorio(raiz, ['status', '--porcelain=v1', '-z', '--untracked-files=no']).length > 0;
+    const revisao = head.ok ? head.saida.toString('utf8').trim() : null;
+    // A5: filtro do Git (eol, LFS) deixa o status limpo com bytes que nao sao o blob da revisao.
+    const motivo = !revisao ? 'sem-commit' : sujo ? 'working-tree-modified' : filtrado ? 'filtro-do-git' : null;
+    return {
+        tenant_id,
+        repository_id: repositorio,
+        revision: motivo === null ? revisao : null,
+        revision_unavailable_reason: motivo,
+        acl_refs,
+        fontes,
+        excluidas,
+    };
+}

package/dist/leases.js

@@ -76,6 +76,8 @@ exports.posicaoNaFila = posicaoNaFila;
 exports.proximoDaFila = proximoDaFila;
 exports.adquirirRegiao = adquirirRegiao;
 exports.tabelaDeLeases = tabelaDeLeases;
+exports.soltarDaThread = soltarDaThread;
+exports.soltarThreadFechada = soltarThreadFechada;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const manifest_1 = require("./manifest");
@@ -83,6 +85,8 @@ const estado_thread_1 = require("./estado-thread");
 const util_1 = require("./util");
 const horario_1 = require("./horario");
 const conducao_texto_1 = require("./conducao-texto");
+const ledger_1 = require("./ledger");
+const thread_1 = require("./thread");
 /** Nome do lease que serializa o merge na base (visao, paridade 5). */
 exports.LEASE_MAIN_TREE = 'main-tree';
 /** TTL padrao de 30 minutos: um SHIP que passe disso deixou de existir. */
@@ -433,6 +437,12 @@ function proximoDaFila(raiz, nome) {
 function adquirirRegiao(raiz, nome, opcoes) {
     const tipo = tipoDoLease(nome);
     const base = { nome, tipo, lease: null, ocupadoPor: null, tomadoDeVencido: false };
+    // A poda e limpeza de estado alheio: erro de E/S nela nunca impede a thread viva de pedir a regiao
+    // (achado A1 do CHECK 1); o que nao saiu agora sai no proximo pedido.
+    try {
+        podarThreadsFechadas(raiz, nome, opcoes.thread);
+    }
+    catch { /* a regra de colisao abaixo decide */ }
     const colidentes = leasesColidentes(raiz, nome, opcoes.thread);
     if (colidentes.length > 0) {
         const dono = colidentes[0];
@@ -550,3 +560,77 @@ function tabelaDeLeases(raiz) {
         linhas.push((0, horario_1.legendaDoFuso)());
     return linhas.join('\n');
 }
+// ---------------------------------------------------------------------------
+// RM-037 (rm037noite, defeito 2): thread fechada nao segura regiao nem fila.
+// ---------------------------------------------------------------------------
+/**
+ * Thread fechada nesta maquina? So `status: fechada` conta: thread que nao existe aqui (outro
+ * perfil, estado apagado) segue contando, porque ninguem prova que ela acabou.
+ */
+function threadFechada(raiz, thread) {
+    try {
+        return (0, thread_1.lerThread)(raiz, thread).status === 'fechada';
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Tira da thread os leases de escrita e as entradas dela na fila. O `exec:` fica de fora: a
+ * conducao tem ciclo proprio e ja trata thread fechada como sem conducao.
+ */
+function soltarDaThread(raiz, thread) {
+    const leases = [];
+    for (const lease of listarLeases(raiz)) {
+        if (lease.thread !== thread || tipoDoLease(lease.nome) === 'exec')
+            continue;
+        // Achado A2 do CHECK 1: rele logo antes de apagar. Outra poda pode ter soltado este lease e uma
+        // thread viva pode ter adquirido o mesmo nome no meio; apagar pelo caminho da listagem levaria o
+        // lease dela. So sai o arquivo que ainda e o da thread fechada, com o mesmo carimbo.
+        const atual = lerLease(raiz, lease.nome);
+        if (!atual || atual.thread !== thread || atual.adquiridoEm !== lease.adquiridoEm)
+            continue;
+        try {
+            fs.unlinkSync(caminhoLease(raiz, lease.nome));
+            leases.push(lease.nome);
+        }
+        catch { /* outra limpeza chegou antes */ }
+    }
+    const fila = lerFila(raiz);
+    const dela = fila.filter((p) => p.thread === thread);
+    if (dela.length > 0)
+        gravarFila(raiz, fila.filter((p) => p.thread !== thread));
+    return { leases, fila: dela.map((p) => p.nome) };
+}
+/**
+ * Solta o que a thread fechada deixou e registra no ledger dela: `lease_released` por lease e
+ * `lease_dequeued` por entrada de fila, com a origem (o fechamento ou a poda de quem pediu a regiao).
+ */
+function soltarThreadFechada(raiz, thread, origem, pedidaPor) {
+    const solto = soltarDaThread(raiz, thread);
+    const dir = (0, thread_1.dirThread)(raiz, thread);
+    const quem = pedidaPor ? { pedidaPor } : {};
+    for (const lease of solto.leases) {
+        (0, ledger_1.registrarSeExiste)(dir, thread, ledger_1.TIPOS_DE_EVENTO.leaseLiberado, { lease, ok: true, detalhe: 'thread fechada: lease solto', origem, ...quem });
+    }
+    for (const lease of solto.fila) {
+        (0, ledger_1.registrarSeExiste)(dir, thread, ledger_1.TIPOS_DE_EVENTO.leaseDesenfileirado, { lease, detalhe: 'thread fechada: saiu da fila', origem, ...quem });
+    }
+    return solto;
+}
+/**
+ * Antes de decidir a vez, quem pede a regiao tira da frente o que e de thread ja fechada: o lease
+ * colidente e a espera na fila. E a cura do que ficou preso antes de o fechamento soltar sozinho
+ * (a ork-companybrai3, fechada, na frente da fila de `path:docs/roadmap/README.md`).
+ */
+function podarThreadsFechadas(raiz, nome, quem) {
+    const suspeitas = new Set([
+        ...listarLeases(raiz).filter((l) => leasesColidem(nome, l.nome)).map((l) => l.thread),
+        ...esperandoPor(raiz, nome).map((p) => p.thread),
+    ]);
+    suspeitas.delete(quem);
+    for (const thread of suspeitas) {
+        if (threadFechada(raiz, thread))
+            soltarThreadFechada(raiz, thread, 'poda', quem);
+    }
+}

package/dist/ledger.js

@@ -99,8 +99,18 @@ exports.TIPOS_DE_EVENTO = {
     worktreeAuditada: 'worktree_audited',
     worktreeLiberada: 'worktree_released',
     leaseEnfileirado: 'lease_queued',
+    // RM-037 (rm037noite, defeito 2): a entrada da fila que saiu porque a thread fechou.
+    leaseDesenfileirado: 'lease_dequeued',
+    // RM-037 (rm037noite, defeito 3): a reserva do roadmap que a thread fechada soltou (ou reapontou),
+    // e a que ficou para depois porque nao deu para soltar agora.
+    reservaLiberada: 'roadmap_reserva_liberada',
+    reservaPendente: 'roadmap_reserva_pendente',
+    // A parte do fechamento que falhou (E/S), com o erro; o fechamento segue valendo.
+    solturaFalhou: 'soltura_ao_fechar_falhou',
     postmortemGravado: 'postmortem_recorded',
     masterConcluido: 'master_done',
+    // RM-048 (item 8): o pedido de nota ao dono, com codigo curto; a nota volta pelo ingresso.
+    notaPedida: 'master_nota_pedida',
     scoreProposto: 'score_proposto',
     masterMigrado: 'master_migrated',
     threadFechadaAdmin: 'thread_closed_admin',
@@ -138,6 +148,8 @@ exports.TIPOS_DE_EVENTO = {
     onboardingRegistrado: 'onboarding_recorded',
     // Correcao do escalonador: vaga devolvida por thread sem procura ativa (`ork board reap`)
     vagaLiberada: 'slot_released',
+    // RM-037 (rm037defeito, defeito 3): o `phase run` recusou o despacho por falta de vaga no projeto.
+    vagaRecusada: 'slot_refused',
     // I-07: estimativa humana no PLAN para comparacao economica posterior.
     estimativaPlano: 'plan_estimate',
     // I-42 (D5): ciclo sem CHECK que nao achou teste nem comando honesto declara a ausencia de
@@ -156,6 +168,8 @@ exports.TIPOS_DE_EVENTO = {
     conducaoLiberada: 'conducao_liberada',
     conducaoOrfaLiberada: 'conducao_orfa_liberada',
     conducaoAssumida: 'conducao_assumida',
+    // RM-037 (rm037defeito, A-1 do CHECK 3): o despacho recusado antes da sessao devolveu o lease que a tomada consumiu.
+    conducaoDevolvida: 'conducao_devolvida',
     conducaoRenovada: 'conducao_renovada',
 };
 /**

package/dist/maestro-cli.js

@@ -31,10 +31,19 @@ function readMaestro(context, options) {
             return sources;
         } });
 }
+/** RM-052: de onde veio o projeto do panorama, na lingua do dono. */
+const ORIGEM_DO_PANORAMA = Object.freeze({
+    installation: 'fixado na instalação', cwd: 'pelo diretório atual', worktree: 'pela worktree da thread',
+    selection: 'pedido explicitamente (--projeto ou ORK_PROJETO)',
+});
 function maestroText(snapshot) {
-    return [`${snapshot.project.name} · panorama Maestro`,
+    const p = snapshot.project;
+    return [`${p.name} · panorama Maestro`,
         // I-35: o snapshot guarda ISO; o texto ao dono diz quando consultou, no fuso dele.
         `• Consulta: ${(0, horario_1.formatarDataHoraRotulada)(snapshot.observedAt, { agora: snapshot.observedAt })}`,
+        // RM-052: qual cópia foi lida e o que o panorama não lê, antes de qualquer seção.
+        `• Projeto consultado: ${p.name}${p.root ? ` · ${p.root}` : ''}${p.remote === undefined ? '' : ` · ${p.remote ?? 'sem remoto'}`} · ${ORIGEM_DO_PANORAMA[p.origin]}`,
+        ...(snapshot.notConsulted?.length ? [`• Não lido: ${snapshot.notConsulted.join(' · ')}`] : []),
         ...maestro_contract_1.SECTION_NAMES.map(name => {
             const s = snapshot.sections[name];
             return `• ${name}: ${s.state} · ${s.coverage.returned}/${s.coverage.total ?? '?'}${s.coverage.omitted ? ' · mais itens disponíveis' : ''}`;

package/dist/maestro-contract.js

@@ -31,10 +31,14 @@ exports.maestroSectionSchema = zod_1.z.object({
 }).strict();
 exports.maestroSnapshotSchema = zod_1.z.object({
     schema: zod_1.z.literal(exports.MAESTRO_SCHEMA), observedAt: zod_1.z.string().datetime(), fingerprint,
-    project: zod_1.z.object({ id: identity, name: text, origin: zod_1.z.enum(['installation', 'cwd', 'worktree', 'selection']), fingerprint }).strict(),
+    // RM-052: a raiz exibida (com ~) e o remoto sem credencial dizem QUAL copia foi lida.
+    project: zod_1.z.object({ id: identity, name: text, origin: zod_1.z.enum(['installation', 'cwd', 'worktree', 'selection']), fingerprint,
+        root: text.optional(), remote: text.nullable().optional() }).strict(),
     limits: zod_1.z.object({ items: zod_1.z.literal(50), bytes: zod_1.z.literal(65536), sourceMs: zod_1.z.literal(2000), totalMs: zod_1.z.literal(10000) }).strict(),
     sections: zod_1.z.object(Object.fromEntries(exports.SECTION_NAMES.map(name => [name, exports.maestroSectionSchema]))).strict(),
     gaps: zod_1.z.array(text).max(100), conflicts: zod_1.z.array(text).max(100),
+    // RM-052: o que o panorama NAO le (roadmap, reservas, outras maquinas): lacuna declarada nunca vira "vazio".
+    notConsulted: zod_1.z.array(text).max(20).optional(),
 }).strict();
 function validateMaestroSnapshot(input) {
     const value = exports.maestroSnapshotSchema.parse(input);

package/dist/maestro-discovery.js

@@ -42,6 +42,20 @@ const node_crypto_1 = require("node:crypto");
 const manifest_1 = require("./manifest");
 const estado_thread_1 = require("./estado-thread");
 const thread_1 = require("./thread");
+const projeto_alvo_1 = require("./projeto-alvo");
+/**
+ * RM-052: o panorama le threads, sessoes e filas deste projeto nesta maquina. Roadmap, reservas e
+ * as outras maquinas NAO entram nele; quem le o panorama precisa saber disso para nao concluir
+ * "roadmap vazio" a partir de zero threads, que foi o incidente de 29/09.
+ */
+function consultaDoMaestro(value, countOtherProjects) {
+    const loaded = (0, manifest_1.carregarManifesto)(value.root);
+    const others = countOtherProjects ? (0, projeto_alvo_1.outrosProjetosConhecidos)(value.root) : 0;
+    return { ...value, project: { ...value.project, root: (0, projeto_alvo_1.raizParaExibir)(value.root),
+            remote: (0, projeto_alvo_1.remotoDoProjeto)(value.root, loaded?.manifesto.fabrica?.remoto ?? 'origin') },
+        notConsulted: [projeto_alvo_1.FORA_DA_CONSULTA.roadmap, projeto_alvo_1.FORA_DA_CONSULTA.reservas, projeto_alvo_1.FORA_DA_CONSULTA.outrasMaquinas,
+            ...(others > 0 ? [`outros projetos desta máquina: ${others} (ork projetos)`] : [])] };
+}
 const inside = (root, file) => file === root || file.startsWith(root + path.sep);
 function physical(file) {
     const absolute = path.resolve(file);
@@ -121,9 +135,9 @@ function discoverMaestro(options) {
                 if (fs.lstatSync(file).isSymbolicLink() && fs.realpathSync(file) !== target)
                     throw Error('maestro.project.scope');
             }
-        return context(canonical, 'worktree');
+        return consultaDoMaestro(context(canonical, 'worktree'), options.countOtherProjects !== false);
     }
-    return context(chosen, origin);
+    return consultaDoMaestro(context(chosen, origin), options.countOtherProjects !== false);
 }
 function revalidateMaestroContext(value) {
     const current = context(value.root, value.project.origin);

package/dist/maestro-snapshot.js

@@ -51,9 +51,13 @@ function maestroSnapshot(context, options = {}) {
             coverage: { total: unavailable ? null : all.length, offset, returned: items.length, omitted: unavailable ? null : omitted,
                 nextOffset: omitted ? offset + items.length : null, limit: 50 }, items, gaps: publicMessages(src?.gaps ?? ['maestro.source.unavailable'], 4) };
     }
+    // RM-052: raiz e remoto passam pela mesma redacao dos demais campos publicos.
+    const { root, remote } = context.project;
     const result = { schema: maestro_contract_1.MAESTRO_SCHEMA, observedAt, fingerprint: (0, maestro_sources_1.digest)([context.fingerprint, sources.fingerprint]),
-        project: { ...context.project, name: (0, maestro_sources_1.safeText)(context.project.name) }, limits: maestro_contract_1.MAESTRO_LIMITS, sections, gaps: publicMessages(sources.gaps, 12),
-        conflicts: publicMessages([...sources.conflicts, ...(!stable ? ['maestro.snapshot.stale'] : [])], 12) };
+        project: { ...context.project, name: (0, maestro_sources_1.safeText)(context.project.name), ...(root === undefined ? {} : { root: (0, maestro_sources_1.safeText)(root) }),
+            ...(remote === undefined ? {} : { remote: remote === null ? null : (0, maestro_sources_1.safeText)(remote) }) }, limits: maestro_contract_1.MAESTRO_LIMITS, sections, gaps: publicMessages(sources.gaps, 12),
+        conflicts: publicMessages([...sources.conflicts, ...(!stable ? ['maestro.snapshot.stale'] : [])], 12),
+        ...(context.notConsulted ? { notConsulted: publicMessages(context.notConsulted, 19) } : {}) };
     // Orçamento incremental; mantém um item por seção para nextOffset avançar.
     const sizes = new Map(Object.values(sections).map(s => [s, Buffer.byteLength(JSON.stringify(s))]));
     let bytes = Buffer.byteLength(JSON.stringify(result));

package/dist/manifest.js

@@ -37,10 +37,13 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LIMITE_MANIFESTO_BYTES = exports.DIR_ESTADO = exports.NOME_MANIFESTO_LEGADO = exports.NOME_MANIFESTO = void 0;
+exports.EMBEDDING_PADRAO = exports.LIMITE_MANIFESTO_BYTES = exports.DIR_ESTADO = exports.NOME_MANIFESTO_LEGADO = exports.NOME_MANIFESTO = void 0;
+exports.fixarDiretorioDoProjeto = fixarDiretorioDoProjeto;
+exports.diretorioDoProjeto = diretorioDoProjeto;
 exports.acharRaiz = acharRaiz;
 exports.dirEstado = dirEstado;
 exports.validarOptInPlaybook = validarOptInPlaybook;
+exports.configDeEmbedding = configDeEmbedding;
 exports.carregarManifesto = carregarManifesto;
 exports.exigirManifesto = exigirManifesto;
 const fs = __importStar(require("node:fs"));
@@ -53,13 +56,28 @@ const slug_1 = require("./slug");
 const util_1 = require("./util");
 const delegation_1 = require("./delegation");
 const horario_1 = require("./horario");
+const experiencia_1 = require("./experiencia");
+const runtime_ambiente_1 = require("./runtime-ambiente");
+const orkmind_1 = require("./orkmind");
 exports.NOME_MANIFESTO = 'orkastery.yaml';
 exports.NOME_MANIFESTO_LEGADO = 'devmaster.yaml';
 exports.DIR_ESTADO = '.orkastery';
 /** Limite duro: o manifesto nao pode virar o novo arquivo de 100 KB. */
 exports.LIMITE_MANIFESTO_BYTES = 16384;
+let diretorioFixado = null;
+/**
+ * RM-052: o projeto-alvo fixado pelo CLI (`--projeto`, `ORK_PROJETO`, host sem cwd) vira o ponto
+ * de partida padrao das raizes. Sem ele, vale o cwd, como sempre. Quem fixa e `fixarProjetoAlvo`.
+ */
+function fixarDiretorioDoProjeto(dir) {
+    diretorioFixado = dir;
+}
+/** De onde as raizes padrao partem: o projeto-alvo fixado ou, sem ele, o cwd do processo. */
+function diretorioDoProjeto() {
+    return diretorioFixado ?? process.cwd();
+}
 /** Raiz do projeto: o diretorio que contem o manifesto; senao, a raiz do repositorio git. */
-function acharRaiz(dirInicial = process.cwd()) {
+function acharRaiz(dirInicial = diretorioDoProjeto()) {
     const porManifesto = (0, util_1.subirAte)(dirInicial, exports.NOME_MANIFESTO);
     if (porManifesto)
         return porManifesto;
@@ -116,6 +134,31 @@ function prazosDoVerify(verify, erros) {
         saida.timeout_ms_por_comando = porComando;
     return saida;
 }
+/**
+ * RM-037 (rm037defeito, defeito 5): `ci.external_repositories`, mapa `dono/nome` para o check exigido no
+ * head do PR (texto vazio ou nulo: repositorio sem CI). Forma invalida e erro do manifesto, nunca adivinhada.
+ */
+function repositoriosExternos(v, erros) {
+    if (v === undefined || v === null)
+        return {};
+    if (typeof v !== 'object' || Array.isArray(v)) {
+        erros.push('ci.external_repositories deve ser um mapa "dono/nome": "check exigido" (vazio para repositorio sem CI)');
+        return {};
+    }
+    const r = {};
+    for (const [repo, check] of Object.entries(v)) {
+        if (!/^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/.test(repo)) {
+            erros.push(`ci.external_repositories: "${repo}" nao e dono/nome do GitHub`);
+            continue;
+        }
+        if (check !== null && typeof check !== 'string') {
+            erros.push(`ci.external_repositories.${repo}: o check exigido e texto (vazio para sem CI)`);
+            continue;
+        }
+        r[repo] = (check ?? '').trim();
+    }
+    return r;
+}
 function booleano(v, padrao) {
     return typeof v === 'boolean' ? v : padrao;
 }
@@ -133,6 +176,81 @@ function validarOptInPlaybook(valor) {
     }
     return valor.ativo;
 }
+/** I-38 (D5): sem o bloco `memory.embedding`, os embeddings ficam desligados. */
+exports.EMBEDDING_PADRAO = Object.freeze({
+    provider: 'none', model: '', dim: 1024, api_key_env: '', fallback_model: '', max_tokens_por_execucao: 1_000_000,
+});
+const CHAVES_DE_EMBEDDING = ['provider', 'model', 'dim', 'api_key_env', 'fallback_model', 'max_tokens_por_execucao'];
+/** Valor que parece segredo (URL, prefixo de chave, sequencia longa) nunca e repetido num erro. */
+function exibir(v) {
+    const t = typeof v === 'string' ? v : JSON.stringify(v);
+    return /:\/\/|\bsk-|[A-Za-z0-9_-]{32,}/.test(t) ? '(valor omitido: parece segredo)' : JSON.stringify(v);
+}
+/**
+ * I-38 (D5): le e valida `memory.embedding`. A chave so entra pelo NOME da variavel: valor com
+ * cara de chave ou DSN reprova o manifesto, e nome da lista de provider pago tambem, porque a
+ * entrada do `ork` apagaria a variavel sob `subscription-only` e o preflight reprovaria o codex.
+ */
+function lerEmbedding(bruto, variavelDaDsn, erros) {
+    if (bruto === undefined || bruto === null)
+        return undefined;
+    if (typeof bruto !== 'object' || Array.isArray(bruto)) {
+        erros.push('memory.embedding precisa ser um bloco com provider, model, dim, api_key_env, fallback_model e max_tokens_por_execucao');
+        return undefined;
+    }
+    const e = bruto;
+    for (const chave of Object.keys(e)) {
+        if (!CHAVES_DE_EMBEDDING.includes(chave)) {
+            erros.push(`memory.embedding.${chave} nao existe (a chave entra pelo ambiente: declare so o NOME em api_key_env)`);
+        }
+    }
+    const provider = texto(e.provider, exports.EMBEDDING_PADRAO.provider).trim();
+    if (provider !== 'none' && provider !== 'openrouter') {
+        erros.push(`memory.embedding.provider invalido: ${exibir(provider)} (aceitos: none, openrouter)`);
+    }
+    const model = texto(e.model, '').trim();
+    const apiKeyEnv = texto(e.api_key_env, '').trim();
+    const fallback = texto(e.fallback_model, '').trim();
+    const inteiro = (chave, v, padrao, min, max) => {
+        if (v === undefined || v === null)
+            return padrao;
+        const n = typeof v === 'number' ? v : typeof v === 'string' && v.trim() !== '' ? Number(v) : NaN;
+        if (!Number.isInteger(n) || n < min || n > max) {
+            erros.push(`memory.embedding.${chave} precisa ser inteiro entre ${min} e ${max} (recebido ${exibir(v)})`);
+            return padrao;
+        }
+        return n;
+    };
+    const dim = inteiro('dim', e.dim, exports.EMBEDDING_PADRAO.dim, 32, 4096);
+    const teto = inteiro('max_tokens_por_execucao', e.max_tokens_por_execucao, exports.EMBEDDING_PADRAO.max_tokens_por_execucao, 1, 10_000_000);
+    if (apiKeyEnv.includes('://') || /^sk-/i.test(apiKeyEnv)) {
+        erros.push('memory.embedding.api_key_env recebe o NOME da variavel de ambiente com a chave, nunca o valor da chave nem uma DSN');
+    }
+    else if (apiKeyEnv !== '' && !/^[A-Z][A-Z0-9_]*$/.test(apiKeyEnv)) {
+        erros.push('memory.embedding.api_key_env invalido: esperado nome de variavel de ambiente, [A-Z][A-Z0-9_]* (o valor recebido nao e repetido)');
+    }
+    else if (runtime_ambiente_1.ENVS_DE_PROVIDER_PAGO.includes(apiKeyEnv)) {
+        erros.push(`memory.embedding.api_key_env nao pode ser ${apiKeyEnv}: nomes de provider pago sao removidos sob subscription-only; use uma chave dedicada com nome proprio`);
+    }
+    else if (apiKeyEnv !== '' && apiKeyEnv === variavelDaDsn) {
+        erros.push('memory.embedding.api_key_env nao pode repetir memory.database_url_env: a DSN nunca vai ao provider');
+    }
+    if (provider === 'openrouter') {
+        if (!orkmind_1.MODELO_DE_EMBEDDING.test(model))
+            erros.push(`memory.embedding.model invalido: ${exibir(model)} (esperado org/nome, por exemplo qwen/qwen3-embedding-8b)`);
+        if (apiKeyEnv === '')
+            erros.push('memory.embedding.api_key_env e obrigatorio com provider openrouter (o NOME da variavel com a chave dedicada)');
+    }
+    if (fallback !== '' && !orkmind_1.MODELO_DE_EMBEDDING.test(fallback)) {
+        erros.push(`memory.embedding.fallback_model invalido: ${exibir(fallback)} (esperado org/nome de um modelo do Hugging Face)`);
+    }
+    return { provider: provider === 'openrouter' ? 'openrouter' : 'none', model, dim, api_key_env: apiKeyEnv,
+        fallback_model: fallback, max_tokens_por_execucao: teto };
+}
+/** I-38 (D5): leitura unica da configuracao de embedding, com o padrao `none`. */
+function configDeEmbedding(manifesto) {
+    return { ...exports.EMBEDDING_PADRAO, ...(manifesto.memory.embedding ?? {}) };
+}
 /** I-33 (N2): texto e numero que dizem sim ou nao sem ambiguidade; o resto nao e reconhecido. */
 const BOOLEANOS_RECONHECIVEIS = new Map([
     ['true', true], ['yes', true], ['on', true], ['sim', true], ['1', true],
@@ -146,7 +264,7 @@ function booleanoReconhecivel(v) {
     return BOOLEANOS_RECONHECIVEIS.get(v.trim().toLowerCase()) ?? null;
 }
 /** Le e valida o manifesto. Nunca lanca: erros e avisos voltam na estrutura. */
-function carregarManifesto(dirInicial = process.cwd()) {
+function carregarManifesto(dirInicial = diretorioDoProjeto()) {
     const raiz = acharRaiz(dirInicial);
     const candidatos = [
         { caminho: path.join(raiz, exports.NOME_MANIFESTO), legado: false },
@@ -171,6 +289,22 @@ function carregarManifesto(dirInicial = process.cwd()) {
     const fusoDoDono = (0, horario_1.lerFusoDoDono)(mapa(dados.owner).timezone);
     if (fusoDoDono.aviso)
         avisos.push(fusoDoDono.aviso);
+    // Preferência inválida segue o fuso: avisa e cai no padrão, sem parar os comandos (e o próprio
+    // onboarding set, que é o caminho para corrigir).
+    const preferencias = {};
+    for (const chave of ['language', 'depth', 'experience']) {
+        const valor = mapa(dados.owner)[chave];
+        if (valor === undefined)
+            continue;
+        try {
+            Object.assign(preferencias, (0, experiencia_1.validarPreferencias)({ [chave]: valor }));
+        }
+        catch (e) {
+            avisos.push(`${e.message}; vale o padrão até corrigir`);
+        }
+    }
+    if (fusoDoDono.origem === 'manifesto')
+        preferencias.timezone = fusoDoDono.fuso;
     const board = mapa(dados.board);
     const runtime = mapa(dados.runtime);
     const conduction = mapa(dados.conduction);
@@ -299,6 +433,7 @@ function carregarManifesto(dirInicial = process.cwd()) {
         avisos.push('memory.mode: orkmind sem memory.database_url_env: o regime efetivo cai para files ' +
             '(o `ork` nao adivinha DSN, e base alheia e pior do que base nenhuma)');
     }
+    const embedding = lerEmbedding(memory.embedding, variavelDaDsn, erros);
     const bytes = Buffer.byteLength(bruto, 'utf8');
     if (bytes > exports.LIMITE_MANIFESTO_BYTES) {
         erros.push(`manifesto com ${bytes} bytes, acima do limite duro de ${exports.LIMITE_MANIFESTO_BYTES} (prosa vai para memoria com tag, nao para o YAML)`);
@@ -313,7 +448,7 @@ function carregarManifesto(dirInicial = process.cwd()) {
             stage: texto(project.stage, 'nascente') ?? 'nascente',
             repo_root: texto(project.repo_root, raiz),
         },
-        ...(fusoDoDono.origem === 'manifesto' ? { owner: { timezone: fusoDoDono.fuso } } : {}),
+        ...(Object.keys(preferencias).length ? { owner: preferencias } : {}),
         board: {
             adapter: texto(board.adapter, 'hermes-kanban'),
             default: texto(board.default, 'default'),
@@ -350,6 +485,7 @@ function carregarManifesto(dirInicial = process.cwd()) {
             required_for_ship: booleano(ci.required_for_ship, false),
             context: texto(ci.context, 'ork-verify'),
             command: ci.command === null || ci.command === undefined ? undefined : texto(ci.command, ''),
+            external_repositories: repositoriosExternos(ci.external_repositories, erros),
         },
         concurrency: {
             max_parallel_threads: numero(concurrency.max_parallel_threads, 3),
@@ -382,6 +518,7 @@ function carregarManifesto(dirInicial = process.cwd()) {
             cli: texto(memory.cli, 'orkmind'),
             tenant: texto(memory.tenant, '') || nomeProjeto,
             timeout_ms: numero(memory.timeout_ms, 15000),
+            ...(embedding ? { embedding } : {}),
         },
         // Bloco B5: governanca de custo dos auditores. Ausente no manifesto quer dizer
         // "nao declarada", nao "sem limite": a rodada avisa que so `eco` e o escopo
@@ -402,7 +539,7 @@ function carregarManifesto(dirInicial = process.cwd()) {
     return { caminho: achado.caminho, raiz, legado: achado.legado, bytes, manifesto, erros, avisos };
 }
 /** Carrega o manifesto ou encerra com mensagem acionavel (uso nos subcomandos). */
-function exigirManifesto(dirInicial = process.cwd()) {
+function exigirManifesto(dirInicial = diretorioDoProjeto()) {
     const carregado = carregarManifesto(dirInicial);
     if (!carregado) {
         throw new Error(`manifesto ${exports.NOME_MANIFESTO} nao encontrado a partir de ${dirInicial}. Rode: ork init`);