@orkastery/cli 0.2.0 → 0.4.1

package/dist/memoria.js

@@ -1,22 +1,4 @@
 "use strict";
-/**
- * A camada de memoria do `ork` (bloco B6): o que o nucleo grava, com que tags, e o que
- * ele injeta de volta no prompt de cada fase.
- *
- * Divisao de trabalho deste bloco:
- *   - `orkmind.ts` sabe FALAR com o OrkMind (transporte, degradacao, governanca);
- *   - `memoria.ts` (aqui) sabe O QUE o Orkastery grava e le de volta (decisao, handoff,
- *     rule, learning, roadmap), e como isso vira contexto de prompt;
- *   - `recall.ts` sabe RESOLVER o que ficou fora do prompt, no momento indicado.
- *
- * Nenhuma regra de negocio nova nasce aqui. Decisao, claim, baseline, achado e score
- * continuam sendo do nucleo que ja existe: esta camada os PUBLICA e os RECUPERA.
- *
- * A propriedade que o B6 precisa provar e a da injecao deterministica: um prompt de fase
- * carrega 100 por cento das decisoes fechadas da thread, venham elas do `thread.json`
- * (regime `files`) ou da colecao `decision` (regime `orkmind`). Por isso a injecao NAO
- * depende do OrkMind estar ligado: ela troca de fonte, nao de garantia.
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -51,13 +33,18 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.sincronizarOnboarding = sincronizarOnboarding;
 exports.abrirMemoria = abrirMemoria;
 exports.tagsDoProjeto = tagsDoProjeto;
 exports.situacaoDaThread = situacaoDaThread;
 exports.situacaoDaFase = situacaoDaFase;
 exports.skillDaColecao = skillDaColecao;
+exports.agenteDaThread = agenteDaThread;
 exports.tagsDaThread = tagsDaThread;
 exports.gravarDecisoes = gravarDecisoes;
+exports.identidadeDoHandoff = identidadeDoHandoff;
+exports.origemCanonicaDoHandoff = origemCanonicaDoHandoff;
+exports.prepararHandoffGovernado = prepararHandoffGovernado;
 exports.gravarHandoff = gravarHandoff;
 exports.gravarPolicies = gravarPolicies;
 exports.gravarLearning = gravarLearning;
@@ -79,19 +66,132 @@ exports.publicarPropostas = publicarPropostas;
 exports.textoDoEstado = textoDoEstado;
 exports.textoDoSync = textoDoSync;
 exports.parsePrioridade = parsePrioridade;
+const write_activation_1 = require("./write-activation");
+const escopo_escrita_1 = require("./escopo-escrita");
+const project_state_1 = require("./project-state");
+/**
+ * A camada de memoria do `ork` (bloco B6): o que o nucleo grava, com que tags, e o que
+ * ele injeta de volta no prompt de cada fase.
+ *
+ * Divisao de trabalho deste bloco:
+ *   - `orkmind.ts` sabe FALAR com o OrkMind (transporte, degradacao, governanca);
+ *   - `memoria.ts` (aqui) sabe O QUE o Orkastery grava e le de volta (decisao, handoff,
+ *     rule, learning, roadmap), e como isso vira contexto de prompt;
+ *   - `recall.ts` sabe RESOLVER o que ficou fora do prompt, no momento indicado.
+ *
+ * Nenhuma regra de negocio nova nasce aqui. Decisao, claim, baseline, achado e score
+ * continuam sendo do nucleo que ja existe: esta camada os PUBLICA e os RECUPERA.
+ *
+ * A propriedade que o B6 precisa provar e a da injecao deterministica: um prompt de fase
+ * carrega 100 por cento das decisoes fechadas da thread, venham elas do `thread.json`
+ * (regime `files`) ou da colecao `decision` (regime `orkmind`). Por isso a injecao NAO
+ * depende do OrkMind estar ligado: ela troca de fonte, nao de garantia.
+ */
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const manifest_1 = require("./manifest");
+const onboarding_1 = require("./onboarding");
+const node_crypto_1 = require("node:crypto");
+const node_util_1 = require("node:util");
+const memoria_humana_1 = require("./memoria-humana");
 const master_1 = require("./master");
 const modos_1 = require("./modos");
 const orkmind_1 = require("./orkmind");
 const ledger_1 = require("./ledger");
 const thread_1 = require("./thread");
 const util_1 = require("./util");
+const licoes_1 = require("./licoes");
+/** Publica somente a entrevista deste projeto; jamais percorre threads. */
+function sincronizarOnboarding(carregado, opcoes = {}) {
+    carregado = (0, project_state_1.memoryState)(carregado).loaded;
+    const estado = (0, onboarding_1.lerOnboarding)(carregado.raiz);
+    const etapas = onboarding_1.ETAPAS_ONBOARDING.filter(e => estado.etapas[e] !== null);
+    const resultado = { regime: 'files', motivo: null, respondidas: etapas.length,
+        gravadas: 0, duplicadas: 0, falhas: 0, detalhe: '' };
+    const degradar = (motivo) => {
+        resultado.regime = 'files';
+        resultado.motivo = motivo;
+        resultado.detalhe = 'Entrevista preservada em arquivos; publicação semântica não concluída. Consulte ork memory status.';
+        (0, ledger_1.registrar)((0, manifest_1.dirEstado)(carregado.raiz), 'projeto', ledger_1.TIPOS_DE_EVENTO.memoriaDegradada, { origem: 'onboarding', motivo, respondidas: etapas.length, gravadas: resultado.gravadas, falhas: resultado.falhas });
+        return resultado;
+    };
+    // Os detalhes devolvidos por um driver podem conter credenciais. Só expor códigos locais.
+    try {
+        const memoria = abrirMemoria(carregado, opcoes);
+        if (!memoria.ativo)
+            return degradar(memoria.estado.motivo ?? 'orkmind.indisponivel');
+        const tenant = memoria.estado.tenant;
+        for (const etapa of etapas) {
+            const resposta = estado.etapas[etapa];
+            const identidade = `onboarding:${encodeURIComponent(tenant)}:${etapa}`;
+            const r = memoria.gravar({ collection: 'decision', priority: 'medium',
+                content: `Onboarding ${onboarding_1.CONTRATO_ONBOARDING} tenant=${JSON.stringify(tenant)} etapa=${etapa}\n${(0, onboarding_1.jsonCanonico)(resposta.conteudo)}`,
+                tags: { ...tagsDoProjeto(carregado.manifesto), skill: ['orkastery-onboarding'],
+                    situation: ['onboarding', identidade] },
+                metadata: { identidade, etapa, tenant, por: resposta.por, respondidaEm: resposta.respondidaEm },
+            });
+            if (!r.ok)
+                resultado.falhas++;
+            else if (r.duplicada)
+                resultado.duplicadas++;
+            else
+                resultado.gravadas++;
+        }
+        if (resultado.falhas)
+            return degradar('orkmind.indisponivel');
+        resultado.regime = 'orkmind';
+        resultado.detalhe = `${resultado.gravadas} nova(s), ${resultado.duplicadas} já existente(s); ${etapas.length} etapa(s) publicada(s).`;
+        return resultado;
+    }
+    catch {
+        resultado.falhas++;
+        return degradar('orkmind.indisponivel');
+    }
+}
+function resolverLeituraRestrita(manifesto, contexto) {
+    if (contexto === undefined)
+        return undefined;
+    if (!contexto || typeof contexto !== 'object' || Array.isArray(contexto) ||
+        Object.keys(contexto).some(k => !['thread', 'limite'].includes(k)))
+        throw Error('memory.query.invalid');
+    const q = (0, orkmind_1.validarConsultaDelimitada)({ collection: 'handoff',
+        escopo: (0, orkmind_1.criarEscopoDeLeitura)(manifesto, contexto.thread), tags: {},
+        limite: contexto.limite === undefined ? orkmind_1.LIMITE_CONSULTA_PADRAO : contexto.limite });
+    return Object.freeze({ ...q.escopo, limite: q.limite });
+}
 /** Abre a memoria do projeto, ja com o regime efetivo resolvido. */
 function abrirMemoria(carregado, opcoes = {}) {
+    const context = (0, project_state_1.memoryState)(carregado);
+    carregado = context.loaded;
+    // Pedido invalido nao abre driver nem executa sua verificacao de saude.
+    const leituraRestrita = resolverLeituraRestrita(carregado.manifesto, opcoes.leituraRestrita);
     const { estado, driver } = (0, orkmind_1.resolverRegime)(carregado.manifesto, opcoes.driver ?? null);
     const ativo = estado.efetivo === 'orkmind' && driver !== null;
+    const consultarRestrito = (collection, tags) => {
+        if (!leituraRestrita)
+            throw Error('memory.query.invalid');
+        const q = (0, orkmind_1.validarConsultaDelimitada)({ collection, tags,
+            escopo: { tenant: leituraRestrita.tenant, thread: leituraRestrita.thread }, limite: leituraRestrita.limite });
+        if (!ativo || !driver)
+            return [];
+        if (typeof driver.consultar !== 'function')
+            throw Error('memory.query.unsupported');
+        return (0, orkmind_1.concluirConsultaDelimitada)(driver.consultar(q), q);
+    };
     return {
+        configSource: context.source,
+        configDivergent: context.divergent,
+        get leituraRestrita() { return leituraRestrita; },
+        raiz: carregado.raiz,
+        submeterHandoff(pedido) {
+            if (!ativo || !driver?.submeterHandoff)
+                return { ok: false, id: null, duplicada: false,
+                    collection: 'handoff', detalhe: 'memory.g3.unavailable' };
+            if (pedido.tenant !== estado.tenant)
+                return { ok: false, id: null, duplicada: false,
+                    collection: 'handoff', detalhe: 'memory.tenant.mismatch' };
+            return driver.submeterHandoff(pedido);
+        },
         estado,
         ativo,
         regime: estado.efetivo,
@@ -118,6 +218,14 @@ function abrirMemoria(carregado, opcoes = {}) {
             return driver.adicionar(entrada);
         },
         buscar(consulta) {
+            if (leituraRestrita) {
+                if (consulta.limite !== undefined && (!Number.isInteger(consulta.limite) ||
+                    consulta.limite < 1 || consulta.limite > orkmind_1.LIMITE_CONSULTA_MAXIMO))
+                    throw Error('memory.query.invalid');
+                const entradas = consultarRestrito(consulta.collection, consulta.tags);
+                // Corte de apresentacao somente depois da janela completa e dos filtros locais.
+                return consulta.limite === undefined ? entradas : entradas.slice(0, consulta.limite);
+            }
             if (!ativo || !driver)
                 return [];
             const colecoes = consulta.collection ? [consulta.collection] : [...orkmind_1.COLECOES_DO_ORK];
@@ -125,6 +233,11 @@ function abrirMemoria(carregado, opcoes = {}) {
             return (0, orkmind_1.filtrarPorTags)(tudo, consulta);
         },
         porId(colecao, id) {
+            if (leituraRestrita) {
+                if (typeof id !== 'string' || !id || id.length > 512 || /[\x00-\x1f\x7f]/.test(id))
+                    throw Error('memory.query.invalid');
+                return consultarRestrito(colecao, {}).find(e => e.id === id) ?? null;
+            }
             if (!ativo || !driver)
                 return null;
             return driver.exportar(colecao).find((e) => e.id === id) ?? null;
@@ -141,7 +254,7 @@ function abrirMemoria(carregado, opcoes = {}) {
 function tagsDoProjeto(manifesto) {
     return {
         project: [manifesto.memory.tenant || manifesto.project.name],
-        agent: ['ork'],
+        agent: ['desconhecido:desconhecido', 'ork'],
         domain: ['orkastery'],
     };
 }
@@ -157,14 +270,27 @@ function situacaoDaFase(fase) {
 function skillDaColecao(colecao) {
     return `orkastery-${colecao}`;
 }
+/** Autoria observada; manifesto do executor nao prova autoria historica. */
+function agenteDaThread(thread, slug) {
+    const sessao = slug ? thread.sessoes.find(s => s.slug === slug) : thread.sessoes.at(-1);
+    if (!sessao)
+        return 'desconhecido:desconhecido';
+    let modelo = 'desconhecido';
+    if (thread.worktree) {
+        const evento = (0, ledger_1.lerLedger)((0, thread_1.dirThread)(thread.worktree, thread.id)).find(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId);
+        if (typeof evento?.model === 'string' && evento.model)
+            modelo = evento.model;
+    }
+    return `${sessao.runtime || 'desconhecido'}:${modelo}`;
+}
 /** As tags completas de uma entrada de thread. */
 function tagsDaThread(manifesto, colecao, thread, fase) {
-    const situacao = [situacaoDaThread(thread.id), `modo:${thread.modo}`];
-    if (fase)
-        situacao.push(situacaoDaFase(fase));
+    const aplicavel = fase ?? thread.faseAtual;
+    const situacao = [colecao, situacaoDaThread(thread.id), `modo:${thread.modo}`, situacaoDaFase(aplicavel)];
     return {
         ...tagsDoProjeto(manifesto),
-        skill: [skillDaColecao(colecao)],
+        agent: [agenteDaThread(thread), 'ork'],
+        skill: [aplicavel, skillDaColecao(colecao)],
         situation: situacao,
     };
 }
@@ -202,14 +328,15 @@ function gravarDecisoes(memoria, manifesto, thread) {
             // metadata, entao a identidade da entrada precisa viajar por onde a busca por
             // tag ja e exata. Sem ela, a mesma decisao voltaria duas vezes ao prompt (uma
             // do thread.json, outra da memoria), porque nao haveria como deduplicar.
-            tags: {
+            tags: Object.fromEntries(Object.entries({
                 ...tagsDaThread(manifesto, 'decision', thread),
                 situation: [
+                    'decision',
                     situacaoDaThread(thread.id),
                     `modo:${thread.modo}`,
                     `decisao:${d.id}`,
                 ],
-            },
+            }).map(([k, v]) => [k, [...new Set(v)].sort()])),
             priority: 'high',
             metadata: {
                 thread: thread.id,
@@ -223,43 +350,81 @@ function gravarDecisoes(memoria, manifesto, thread) {
     }
     return juntar(resultados, memoria.regime);
 }
-/**
- * Grava o pacote de handoff da fase na colecao `handoff`.
- *
- * O corpo gravado e o RESUMO tipado (contagens, momento, itens criticos), nao o JSON
- * inteiro: o handoff completo continua commitado em `.orkastery/threads/<id>/`, e o
- * ponteiro do proprio handoff diz onde ele esta. Memoria semantica nao e backup.
- */
+/** Identidade independente da worktree: tenant, caminho canonico e bytes da origem. */
+function identidadeDoHandoff(tenant, arquivo, sha256) {
+    const digest = (0, node_crypto_1.createHash)('sha256').update([tenant, arquivo, sha256].join('\0')).digest('hex');
+    return digest.match(/.{8}/g).join(':');
+}
+function origemCanonicaDoHandoff(arquivo) {
+    const normalizado = arquivo.split(path.sep).join('/');
+    const inicio = normalizado.lastIndexOf('.orkastery/');
+    return inicio >= 0 ? normalizado.slice(inicio) : normalizado;
+}
+/** Adaptacao do v1 para o G3. Ausencias sao declaradas; o original fica integral. */
+function prepararHandoffGovernado(manifesto, thread, handoff, arquivo, textoOriginal, raiz) {
+    const tenant = manifesto.memory.tenant || manifesto.project.name;
+    if (thread.projeto.name !== manifesto.project.name || handoff.thread !== thread.id) {
+        throw new Error('memory.tenant.mismatch');
+    }
+    if (!(0, node_util_1.isDeepStrictEqual)(JSON.parse(textoOriginal), handoff))
+        throw new Error('memory.handoff.source-mismatch');
+    if (!handoff.de?.slug || !handoff.para?.slug || !Array.isArray(handoff.inline) ||
+        !Array.isArray(handoff.pointers) || !Array.isArray(handoff.summaries))
+        throw new Error('memory.handoff.invalid');
+    arquivo = origemCanonicaDoHandoff(arquivo);
+    const sha256 = (0, node_crypto_1.createHash)('sha256').update(textoOriginal).digest('hex');
+    const identidade = identidadeDoHandoff(tenant, arquivo, sha256);
+    const anteriores = thread.sessoes.filter(s => s.origem !== 'adocao' && s.fase === handoff.de.fase &&
+        Date.parse(s.despachadaEm) <= Date.parse(handoff.geradoEm));
+    const exata = anteriores.find(s => s.slug === handoff.de.slug);
+    // O v1 exportava thread.slug no campo de.slug. A data/fase identifica a sessao
+    // efetivamente em curso quando o arquivo foi produzido, sem atribuir o migrador.
+    const sessao = exata ?? (handoff.de.slug === thread.slug ? anteriores.at(-1) : undefined);
+    const evento = sessao ? (0, ledger_1.lerLedger)((0, thread_1.dirThread)(raiz, thread.id)).find(e => e.tipo === 'phase_dispatch' && e.sessionId === sessao.sessionId) : undefined;
+    const agente = `${sessao?.runtime || 'desconhecido'}:${typeof evento?.model === 'string' ? evento.model : 'desconhecido'}`;
+    const sessionId = sessao?.sessionId || `origem-declarada:${tenant}:${thread.id}:${handoff.de.slug}`;
+    const autoria = { sessionId, slug: sessao?.slug ?? handoff.de.slug, agente,
+        criterio: exata ? 'slug, fase e data do despacho' : sessao ? 'ultima sessao da fase anterior ao arquivo; slug v1 da thread' :
+            'somente slug declarado no arquivo; runtime e modelo desconhecidos',
+        evidencia: sessao ? `.orkastery/threads/${thread.id}/thread.json#json:sessoes` : `${arquivo}#json:de` };
+    const decisoes = handoff.inline.filter(i => /decis[aã]o/i.test(i.titulo) || i.proveniencia.location.includes('decisoes'));
+    const tags = { ...tagsDaThread(manifesto, 'handoff', thread, handoff.para.fase ?? undefined), agent: [agente, 'ork'] };
+    const progresso = `Handoff da thread ${thread.id} de ${handoff.de.slug} (${handoff.de.fase}) para ` +
+        `${handoff.para.slug} (${handoff.para.fase}), regime ${handoff.memory}.\n` +
+        `Triagem: ${handoff.inline.length} inline, ${handoff.pointers.length} ponteiros e ${handoff.summaries.length} resumos.\n` +
+        `Arquivo commitado: ${arquivo}\nResumos declarados na origem: ${JSON.stringify(handoff.summaries)}`;
+    return { tenant, identidade, sessionId, origem: handoff.de.slug, destino: handoff.para.slug, tags,
+        metadata: { tenant, thread: thread.id, arquivo, sha256, bytes: Buffer.byteLength(textoOriginal),
+            de: handoff.de, para: handoff.para, autoria },
+        payload: {
+            progresso,
+            decisoes: decisoes.length ? `Decisoes declaradas no pacote original, preservadas a seguir:\n${JSON.stringify(decisoes)}` :
+                'O pacote original nao declara decisoes inline identificaveis. Esta ausencia foi preservada, sem inferir uma decisao.',
+            referencias_criticas: `Caminhos e ancoras declarados pelo produtor; hashes integrais permanecem no pacote original:\n${JSON.stringify({
+                inline: handoff.inline.map(i => i.proveniencia.location),
+                pointers: handoff.pointers.map(p => ({ location: p.location, retrieve_when: p.retrieve_when }))
+            })}`,
+            proximos_passos: `Destino declarado: ${handoff.para.slug}, fase ${handoff.para.fase ?? 'nao declarada'}. ` +
+                `Momentos de recuperacao dos ponteiros: ${JSON.stringify(handoff.pointers.map(p => ({ id: p.id, retrieve_when: p.retrieve_when })))}. ` +
+                'O formato v1 nao declara outra lista de tarefas seguintes; nenhuma foi inferida nesta adaptacao.',
+            original: handoff, original_texto: textoOriginal, orkastery_identity: identidade,
+        } };
+}
+/** Publica exclusivamente por G3, com readback; arquivo ausente nunca vira pacote vazio. */
 function gravarHandoff(memoria, manifesto, thread, handoff, caminhoRelativo) {
-    const criticos = handoff.inline.map((i) => `- ${i.titulo} (${i.proveniencia.location})`).join('\n');
-    return memoria.gravar({
-        collection: 'handoff',
-        content: `Handoff da thread ${thread.id} de ${handoff.de.slug} (${handoff.de.fase}) para ` +
-            `${handoff.para.slug} (${handoff.para.fase}), regime ${handoff.memory}.\n` +
-            `Triagem: ${handoff.inline.length} inline (CRITICO), ${handoff.pointers.length} ponteiro(s) ` +
-            `(IMPORTANTE), ${handoff.summaries.length} resumo(s) (RESUMIVEL).\n` +
-            `Arquivo commitado: ${caminhoRelativo}\n` +
-            `Itens criticos:\n${criticos || '- (nenhum)'}`,
-        tags: {
-            ...tagsDaThread(manifesto, 'handoff', thread),
-            situation: [
-                situacaoDaThread(thread.id),
-                `modo:${thread.modo}`,
-                ...(handoff.para.fase ? [situacaoDaFase(handoff.para.fase)] : []),
-                `slug:${handoff.para.slug}`,
-            ],
-        },
-        priority: 'high',
-        metadata: {
-            thread: thread.id,
-            de: handoff.de,
-            para: handoff.para,
-            arquivo: caminhoRelativo,
-            inline: handoff.inline.length,
-            pointers: handoff.pointers.length,
-            summaries: handoff.summaries.length,
-        },
-    });
+    try {
+        const arquivo = path.resolve(memoria.raiz, caminhoRelativo);
+        const textoOriginal = fs.readFileSync(arquivo, 'utf8');
+        const pedido = prepararHandoffGovernado(manifesto, thread, handoff, caminhoRelativo, textoOriginal, memoria.raiz);
+        const resultado = memoria.submeterHandoff(pedido);
+        if (memoria.ativo && !resultado.ok)
+            throw new Error(resultado.detalhe);
+        return resultado;
+    }
+    catch {
+        // Falha de publicacao precisa reprovar export/sync, preservando o arquivo de origem.
+        throw new Error('memory.handoff.failed: fonte, G3 ou readback nao confirmado');
+    }
 }
 /**
  * Grava as policies do manifesto na colecao `rule`.
@@ -279,8 +444,8 @@ function gravarPolicies(memoria, manifesto) {
                 'e regra mandatoria do ecossistema.',
             tags: {
                 ...tagsDoProjeto(manifesto),
-                skill: [skillDaColecao('rule')],
-                situation: [`policy:${nome}`, `postura:${postura}`],
+                skill: ['GOAL', 'PLAN', 'GO', 'CHECK', 'SHIP', 'MASTER', skillDaColecao('rule')],
+                situation: ['policy', `policy:${nome}`, `postura:${postura}`],
             },
             priority: 'high',
             metadata: { policy: nome, postura, origem: 'orkastery.yaml' },
@@ -310,8 +475,9 @@ function gravarLearning(memoria, manifesto, thread, postmortem, master) {
             `Postmortem: .orkastery/threads/${thread.id}/POSTMORTEM.json`,
         tags: {
             ...tagsDoProjeto(manifesto),
-            skill: [skillDaColecao('learning')],
+            skill: ['GOAL', skillDaColecao('learning')],
             situation: [
+                'learning',
                 situacaoDaThread(thread.id),
                 `score:${master.score}`,
                 ...postmortem.classesDeFalha.map((c) => `classe:${c}`),
@@ -340,7 +506,7 @@ function gravarOrigemDaThread(memoria, manifesto, thread, origem) {
             `Modo ${(0, modos_1.tagDoModo)(thread.modo)}, base ${thread.base.branch} @ ${thread.base.commit}.`,
         tags: {
             ...tagsDaThread(manifesto, 'roadmap', thread),
-            situation: [situacaoDaThread(thread.id), `origem:${origem.tipo}`],
+            situation: ['roadmap', situacaoDaThread(thread.id), `origem:${origem.tipo}`],
         },
         priority: 'medium',
         metadata: {
@@ -370,8 +536,9 @@ function gravarPropostaDeAuditoria(memoria, manifesto, achado) {
             `Claim do auditor: ${achado.claim.alegacao} (verificar com: ${achado.claim.verificar.join(' && ') || 'sem comando'})`,
         tags: {
             ...tagsDoProjeto(manifesto),
-            skill: [skillDaColecao('roadmap')],
+            skill: ['GOAL', skillDaColecao('roadmap')],
             situation: [
+                'proposta_auditoria',
                 `achado:${achado.id}`,
                 `rodada:${achado.rodada}`,
                 `pack:${achado.pack}`,
@@ -453,6 +620,9 @@ function decisoesDaThreadNaMemoria(memoria, manifesto, thread) {
  * de ter fechado, e repetir a propria licao no GOAL so gasta janela.
  */
 function licoesDoProduto(memoria, manifesto, threadCorrente, limite = 5) {
+    if (memoria.ativo && memoria.leituraRestrita) {
+        throw Error('memory.query.broad-operation: licoes do produto exigem contexto de manutencao ou regime files');
+    }
     const todas = memoria.buscar({
         collection: 'learning',
         tags: {
@@ -487,6 +657,7 @@ function primeiraLinha(texto) {
  *  - Todo item declara a proveniencia: `path#ancora` ou `orkmind://<colecao>/<id>`.
  */
 function injecaoDaFase(carregado, memoria, thread, fase) {
+    carregado = (0, project_state_1.memoryState)(carregado).loaded;
     const { manifesto } = carregado;
     const itens = [];
     const caminhoThread = `.orkastery/threads/${thread.id}/thread.json`;
@@ -545,6 +716,23 @@ function injecaoDaFase(carregado, memoria, thread, fase) {
             });
         }
     }
+    // I-55 (RM-008): a licao dos POSTMORTEMs em disco volta no GOAL e no PLAN, em qualquer regime.
+    // E um item so, agregado: o que mais bloqueou, o que mais fechou thread e as notas baixas. No
+    // GOAL ela so entra quando o OrkMind nao trouxe licao, para o prompt nao repetir a mesma thread.
+    if (fase === 'PLAN' || (fase === 'GOAL' && licoes === 0)) {
+        const texto = (0, licoes_1.textoDasLicoes)((0, licoes_1.resumoDasLicoes)(carregado.raiz, thread.id));
+        if (texto) {
+            licoes += 1;
+            add({
+                colecao: 'learning',
+                titulo: 'Licoes das threads fechadas deste produto (POSTMORTEM e MASTER)',
+                conteudo: texto,
+                origem: 'postmortem',
+                location: '.orkastery/threads/*/POSTMORTEM.json',
+                mandatory: false,
+            });
+        }
+    }
     // 3. Regras `mandatory` do ecossistema: elas sempre voltam quando as tags casam, em
     // qualquer fase. O `ork` nunca as cria; ele apenas as respeita.
     let regras = 0;
@@ -628,22 +816,35 @@ function caminhoRelativoDoHandoff(raiz, threadId) {
  * vezes nao duplica decisao nem licao. Em regime `files` ele nao falha: ele relata que
  * nada foi para a memoria semantica, e por que.
  */
-function sincronizarMemoria(carregado, memoria, threadId, origem) {
+function sincronizarMemoria(carregado, memoria, threadId, origem, perfil = 'integral') {
+    carregado = (0, project_state_1.memoryState)(carregado).loaded;
     const { raiz, manifesto } = carregado;
+    if (!['fabrica', 'integral'].includes(perfil) || (perfil === 'fabrica' && !threadId))
+        throw Error('memory.publication.profile-invalid');
     const vazio = juntar([], memoria.regime);
     let decisoes = vazio;
     let handoff = null;
     let learning = null;
     let roadmap = null;
-    const policies = gravarPolicies(memoria, manifesto);
+    if (threadId) {
+        (0, escopo_escrita_1.validarDiretorioDeThread)(raiz, threadId);
+        const autorizada = (0, thread_1.lerThread)(raiz, threadId);
+        if (autorizada.projeto.name !== manifesto.project.name)
+            throw new Error('memory.tenant.mismatch');
+    }
+    const policies = perfil === 'integral' ? gravarPolicies(memoria, manifesto)
+        : { ...vazio, detalhe: 'fora do perfil fabrica: rules exigem sync integral; nenhuma tentativa feita' };
+    const humanos = threadId ? (0, memoria_humana_1.publicarGatesHumanos)(carregado, memoria, threadId)
+        : { inventario: [], resultados: [], elegiveis: 0, excluidos: 0, falhas: 0 };
     if (threadId) {
         const thread = (0, thread_1.lerThread)(raiz, threadId);
         decisoes = gravarDecisoes(memoria, manifesto, thread);
-        roadmap = gravarOrigemDaThread(memoria, manifesto, thread, origem ?? {
-            tipo: 'pedido',
-            referencia: '',
-            detalhe: `Thread aberta no modo ${(0, modos_1.tagDoModo)(thread.modo)} para "${thread.nome}".`,
-        });
+        if (perfil === 'integral')
+            roadmap = gravarOrigemDaThread(memoria, manifesto, thread, origem ?? {
+                tipo: 'pedido',
+                referencia: '',
+                detalhe: `Thread aberta no modo ${(0, modos_1.tagDoModo)(thread.modo)} para "${thread.nome}".`,
+            });
         const caminhoDoHandoff = path.join((0, thread_1.dirThread)(raiz, threadId), 'handoff.json');
         if (fs.existsSync(caminhoDoHandoff)) {
             const pacote = (0, util_1.lerJson)(caminhoDoHandoff);
@@ -652,19 +853,22 @@ function sincronizarMemoria(carregado, memoria, threadId, origem) {
         // A licao so existe depois do MASTER: sem score humano nao ha o que ensinar a
         // proxima thread, e inventar licao de thread aberta e self-report.
         const caminhoDoPostmortem = (0, master_1.caminhoPostmortem)(raiz, threadId);
-        const master = (0, master_1.lerMasterLog)(raiz, threadId);
+        const master = perfil === 'integral' ? (0, master_1.lerMasterLog)(raiz, threadId) : null;
         if (master && fs.existsSync(caminhoDoPostmortem)) {
             const postmortem = (0, util_1.lerJson)(caminhoDoPostmortem);
             learning = gravarLearning(memoria, manifesto, thread, postmortem, master);
         }
     }
     const unitarios = [handoff, learning, roadmap].filter((g) => g !== null);
-    const total = decisoes.gravadas.length + policies.gravadas.length + unitarios.length;
-    const falhas = decisoes.falhas + policies.falhas + unitarios.filter((g) => !g.ok).length;
+    const total = decisoes.gravadas.length + policies.gravadas.length + unitarios.length + humanos.resultados.length;
+    const falhas = decisoes.falhas + policies.falhas + unitarios.filter((g) => !g.ok).length + humanos.falhas;
     return {
         regime: memoria.regime,
         estado: memoria.estado,
         thread: threadId,
+        perfil,
+        colecoesForaDoPerfil: perfil === 'fabrica' ? ['rule', 'learning', 'roadmap'] : [],
+        humanos,
         decisoes,
         policies,
         handoff,
@@ -682,8 +886,29 @@ function sincronizarMemoria(carregado, memoria, threadId, origem) {
  * resultado dizendo que nada foi gravado, e o comando segue igual.
  */
 function publicar(carregado, threadId, origem, memoriaAberta) {
+    carregado = (0, project_state_1.memoryState)(carregado).loaded;
+    if (threadId)
+        (0, escopo_escrita_1.validarDiretorioDeThread)(carregado.raiz, threadId);
+    let perfil = 'integral', motivo = null;
+    if (!memoriaAberta && carregado.manifesto.memory.mode === 'orkmind') {
+        try {
+            perfil = (0, write_activation_1.exigirAtivacao)(carregado, threadId ?? '', 'memory').perfil;
+        }
+        catch (e) {
+            motivo = e instanceof Error && /^(write\.activation|scope\.|memory\.tenant)/.test(e.message) ? e.message : 'write.activation.invalid';
+        }
+    }
     const memoria = memoriaAberta ?? abrirMemoria(carregado);
-    const r = sincronizarMemoria(carregado, memoria, threadId, origem);
+    if (motivo && memoria.ativo) {
+        const vazio = { ...juntar([], memoria.regime), detalhe: motivo };
+        return { regime: memoria.regime, estado: memoria.estado, thread: threadId, perfil,
+            publicacao: { estado: 'pendente', motivo }, humanos: { inventario: [], resultados: [], elegiveis: 0, excluidos: 0, falhas: 0 },
+            decisoes: vazio, policies: vazio, handoff: null, learning: null, roadmap: null, total: 0, falhas: 1 };
+    }
+    const r = sincronizarMemoria(carregado, memoria, threadId, origem, perfil);
+    // O driver files apenas relata tentativas recusadas; conserva a degradacao publicada.
+    if (motivo)
+        r.publicacao = { estado: 'pendente', motivo };
     if (threadId && memoria.ativo) {
         (0, ledger_1.registrar)((0, thread_1.dirThread)(carregado.raiz, threadId), threadId, ledger_1.TIPOS_DE_EVENTO.memoriaGravada, {
             origem: origem?.tipo ?? 'sync',
@@ -691,6 +916,7 @@ function publicar(carregado, threadId, origem, memoriaAberta) {
             tenant: memoria.estado.tenant,
             decisoes: r.decisoes.gravadas.length,
             policies: r.policies.gravadas.length,
+            humanGates: r.humanos.elegiveis,
             handoff: r.handoff?.id ?? null,
             learning: r.learning?.id ?? null,
             roadmap: r.roadmap?.id ?? null,
@@ -706,7 +932,13 @@ function publicar(carregado, threadId, origem, memoriaAberta) {
  * board em arquivo e chega ao roadmap do produto pela memoria, quando ela esta ligada.
  */
 function publicarPropostas(carregado, achados, memoriaAberta) {
+    carregado = (0, project_state_1.memoryState)(carregado).loaded;
     const memoria = memoriaAberta ?? abrirMemoria(carregado);
+    // Propostas globais nao herdam uma autorizacao de thread por conveniencia.
+    if (!memoriaAberta && carregado.manifesto.memory.mode === 'orkmind')
+        return juntar(achados.map(() => ({
+            ok: false, id: null, duplicada: false, collection: 'roadmap', detalhe: 'write.activation.operator-required'
+        })), memoria.regime);
     const resultados = achados.map((a) => gravarPropostaDeAuditoria(memoria, carregado.manifesto, a));
     return juntar(resultados, memoria.regime);
 }
@@ -734,7 +966,7 @@ function textoDoEstado(estado) {
         linhas.push(`  ${estado.detalhe}`);
         linhas.push('');
         linhas.push(`  colecoes gravadas: ${orkmind_1.COLECOES_DO_ORK.join(', ')}`);
-        linhas.push('  governanca: source=agent, mandatory=false, rule/instruction nunca critical.');
+        linhas.push('  governanca: source=agent; decision/human exige human_gate comprovado; mandatory=false e regra nunca critical.');
     }
     return linhas.join('\n');
 }
@@ -742,12 +974,16 @@ function textoDoEstado(estado) {
 function textoDoSync(r) {
     const linhas = [];
     linhas.push(`Sincronizacao de memoria (regime ${r.regime})${r.thread ? ` da thread ${r.thread}` : ''}`);
+    linhas.push(`Perfil: ${r.perfil ?? 'integral'}; fora do perfil: ${(r.colecoesForaDoPerfil ?? []).join(', ') || '(nenhuma)'}`);
+    if (r.publicacao?.estado === 'pendente')
+        linhas.push(`Publicacao pendente: ${r.publicacao.motivo}`);
     linhas.push('');
     const linha = (nome, s) => {
         linhas.push(`  ${nome.padEnd(10)} ${s.gravadas.length} entrada(s): ${s.detalhe}`);
     };
     linha('decision', r.decisoes);
     linha('rule', r.policies);
+    linhas.push(`  human_gate ${r.humanos.elegiveis} elegiveis, ${r.humanos.excluidos} excluidos, ${r.humanos.falhas} falhas`);
     const um = (nome, g) => {
         linhas.push(`  ${nome.padEnd(10)} ${g ? (g.ok ? `${g.duplicada ? 'ja existente' : 'gravado'} (${g.id})` : `nao gravado: ${g.detalhe}`) : '(nada a gravar)'}`);
     };