@orkastery/cli 0.2.0

package/dist/memoria.js

@@ -0,0 +1,773 @@
+"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);
+    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.abrirMemoria = abrirMemoria;
+exports.tagsDoProjeto = tagsDoProjeto;
+exports.situacaoDaThread = situacaoDaThread;
+exports.situacaoDaFase = situacaoDaFase;
+exports.skillDaColecao = skillDaColecao;
+exports.tagsDaThread = tagsDaThread;
+exports.gravarDecisoes = gravarDecisoes;
+exports.gravarHandoff = gravarHandoff;
+exports.gravarPolicies = gravarPolicies;
+exports.gravarLearning = gravarLearning;
+exports.gravarOrigemDaThread = gravarOrigemDaThread;
+exports.gravarPropostaDeAuditoria = gravarPropostaDeAuditoria;
+exports.decisaoDaEntrada = decisaoDaEntrada;
+exports.threadDaEntrada = threadDaEntrada;
+exports.arquivoDoHandoff = arquivoDoHandoff;
+exports.postmortemDaLicao = postmortemDaLicao;
+exports.decisoesDaThreadNaMemoria = decisoesDaThreadNaMemoria;
+exports.licoesDoProduto = licoesDoProduto;
+exports.regrasDoProjeto = regrasDoProjeto;
+exports.injecaoDaFase = injecaoDaFase;
+exports.textoDaInjecao = textoDaInjecao;
+exports.caminhoRelativoDoHandoff = caminhoRelativoDoHandoff;
+exports.sincronizarMemoria = sincronizarMemoria;
+exports.publicar = publicar;
+exports.publicarPropostas = publicarPropostas;
+exports.textoDoEstado = textoDoEstado;
+exports.textoDoSync = textoDoSync;
+exports.parsePrioridade = parsePrioridade;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+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");
+/** Abre a memoria do projeto, ja com o regime efetivo resolvido. */
+function abrirMemoria(carregado, opcoes = {}) {
+    const { estado, driver } = (0, orkmind_1.resolverRegime)(carregado.manifesto, opcoes.driver ?? null);
+    const ativo = estado.efetivo === 'orkmind' && driver !== null;
+    return {
+        estado,
+        ativo,
+        regime: estado.efetivo,
+        gravar(entrada) {
+            const problemas = (0, orkmind_1.violacoesDeGovernanca)(entrada);
+            if (problemas.length > 0) {
+                return {
+                    ok: false,
+                    id: null,
+                    duplicada: false,
+                    collection: entrada.collection,
+                    detalhe: `governanca: ${problemas.join('; ')}`,
+                };
+            }
+            if (!ativo || !driver) {
+                return {
+                    ok: false,
+                    id: null,
+                    duplicada: false,
+                    collection: entrada.collection,
+                    detalhe: `regime ${estado.efetivo}: nada gravado na memoria semantica (${estado.detalhe})`,
+                };
+            }
+            return driver.adicionar(entrada);
+        },
+        buscar(consulta) {
+            if (!ativo || !driver)
+                return [];
+            const colecoes = consulta.collection ? [consulta.collection] : [...orkmind_1.COLECOES_DO_ORK];
+            const tudo = colecoes.flatMap((c) => driver.exportar(c));
+            return (0, orkmind_1.filtrarPorTags)(tudo, consulta);
+        },
+        porId(colecao, id) {
+            if (!ativo || !driver)
+                return null;
+            return driver.exportar(colecao).find((e) => e.id === id) ?? null;
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// Tags: as 5 dimensoes, montadas em um lugar so.
+// ---------------------------------------------------------------------------
+/**
+ * As tags de projeto. Toda entrada gravada pelo `ork` carrega estas tres dimensoes, e e
+ * por elas que a busca deterministica encontra o que e daquele produto e daquele agente.
+ */
+function tagsDoProjeto(manifesto) {
+    return {
+        project: [manifesto.memory.tenant || manifesto.project.name],
+        agent: ['ork'],
+        domain: ['orkastery'],
+    };
+}
+/** Tag de situacao que amarra uma entrada a uma thread. */
+function situacaoDaThread(threadId) {
+    return `thread:${threadId}`;
+}
+/** Tag de situacao que amarra uma entrada a uma fase. */
+function situacaoDaFase(fase) {
+    return `fase:${fase}`;
+}
+/** Tag de skill por colecao: e o recorte que separa decisao de licao na mesma base. */
+function skillDaColecao(colecao) {
+    return `orkastery-${colecao}`;
+}
+/** 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));
+    return {
+        ...tagsDoProjeto(manifesto),
+        skill: [skillDaColecao(colecao)],
+        situation: situacao,
+    };
+}
+function juntar(resultados, regime) {
+    const duplicadas = resultados.filter((r) => r.ok && r.duplicada).length;
+    const falhas = resultados.filter((r) => !r.ok).length;
+    const novas = resultados.filter((r) => r.ok && !r.duplicada).length;
+    return {
+        regime,
+        gravadas: resultados,
+        duplicadas,
+        falhas,
+        detalhe: regime === 'files'
+            ? 'regime files: nada foi para a memoria semantica (degradacao honesta)'
+            : `${novas} nova(s), ${duplicadas} ja existente(s), ${falhas} falha(s)`,
+    };
+}
+/**
+ * Grava as decisoes FECHADAS (`locked`) da thread na colecao `decision`.
+ *
+ * Prioridade `high` e nunca `mandatory`: quem transforma uma decisao de thread em regra
+ * do ecossistema e o humano, no OrkMind, com a autenticacao dele.
+ */
+function gravarDecisoes(memoria, manifesto, thread) {
+    const resultados = [];
+    for (const d of thread.decisoes ?? []) {
+        if (!d.locked)
+            continue;
+        resultados.push(memoria.gravar({
+            collection: 'decision',
+            content: `Decisao ${d.id} fechada na thread ${thread.id} ("${thread.nome}") do produto ` +
+                `${thread.projeto.name}.\n${d.texto}\n` +
+                `Fechada por ${d.decididaPor} em ${d.decididaEm}. Modo de conducao: ${(0, modos_1.tagDoModo)(thread.modo)}.`,
+            // A tag `decisao:<id>` NAO e enfeite: o CLI do OrkMind nao tem canal de
+            // 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: {
+                ...tagsDaThread(manifesto, 'decision', thread),
+                situation: [
+                    situacaoDaThread(thread.id),
+                    `modo:${thread.modo}`,
+                    `decisao:${d.id}`,
+                ],
+            },
+            priority: 'high',
+            metadata: {
+                thread: thread.id,
+                decisao: d.id,
+                locked: true,
+                produto: thread.projeto.name,
+                decididaPor: d.decididaPor,
+                decididaEm: d.decididaEm,
+            },
+        }));
+    }
+    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.
+ */
+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,
+        },
+    });
+}
+/**
+ * Grava as policies do manifesto na colecao `rule`.
+ *
+ * Sem `mandatory` e sem `critical`, sempre: o `ork` publica a policy do projeto como
+ * conhecimento recuperavel, e NAO se promove a autor de regra do ecossistema. Promover
+ * uma policy a regra mandatoria e ato de humano autenticado no OrkMind.
+ */
+function gravarPolicies(memoria, manifesto) {
+    const resultados = [];
+    for (const [nome, postura] of Object.entries(manifesto.policies ?? {})) {
+        resultados.push(memoria.gravar({
+            collection: 'rule',
+            content: `Policy "${nome}" do produto ${manifesto.project.name}: postura ${postura}.\n` +
+                'Declarada em orkastery.yaml (policies) e avaliada pelo gate tipado do ork antes ' +
+                'de todo despacho de fase. Esta entrada e publicacao do ork (source: agent) e nao ' +
+                'e regra mandatoria do ecossistema.',
+            tags: {
+                ...tagsDoProjeto(manifesto),
+                skill: [skillDaColecao('rule')],
+                situation: [`policy:${nome}`, `postura:${postura}`],
+            },
+            priority: 'high',
+            metadata: { policy: nome, postura, origem: 'orkastery.yaml' },
+        }));
+    }
+    return juntar(resultados, memoria.regime);
+}
+/**
+ * Grava a licao da thread fechada na colecao `learning`.
+ *
+ * E a entrada que uma thread NOVA do mesmo produto recebe no GOAL: score, classes de
+ * falha e o resumo do postmortem, com a thread de origem declarada.
+ */
+function gravarLearning(memoria, manifesto, thread, postmortem, master) {
+    const classes = postmortem.classesDeFalha.join(', ') || 'sem-falha';
+    return memoria.gravar({
+        collection: 'learning',
+        content: `Licao da thread ${thread.id} ("${thread.nome}") do produto ${master.projeto.name}.\n` +
+            `Score humano: ${master.score}/5 por ${master.avaliadoPor}. Justificativa: ${master.justificativa}\n` +
+            `Classes de falha: ${classes}. Modo: ${master.tag}. Variante: ${master.variante ?? 'nenhuma'}.\n` +
+            `Fases percorridas: ${postmortem.fasesPercorridas.map((f) => f.fase).join(' -> ') || '(nenhuma)'}.\n` +
+            `Gates bloqueados: ${postmortem.gatesBloqueados.length}. Pausas humanas: ${postmortem.pausasHumanas}. ` +
+            `Decisoes autonomas: ${postmortem.decisoesAutonomas}.\n` +
+            `Resumo: ${master.resumo}\n` +
+            // Proveniencia no CORPO, e nao so em metadata: e o que permite ao `ork recall`
+            // achar o arquivo commitado desta licao quando o transporte nao carrega metadata.
+            `Postmortem: .orkastery/threads/${thread.id}/POSTMORTEM.json`,
+        tags: {
+            ...tagsDoProjeto(manifesto),
+            skill: [skillDaColecao('learning')],
+            situation: [
+                situacaoDaThread(thread.id),
+                `score:${master.score}`,
+                ...postmortem.classesDeFalha.map((c) => `classe:${c}`),
+            ],
+        },
+        // Licao com score baixo pesa mais na proxima thread: e o que o builder precisa ver
+        // antes de repetir a mesma classe de falha.
+        priority: master.score <= 2 ? 'high' : 'medium',
+        metadata: {
+            thread: thread.id,
+            score: master.score,
+            classes: postmortem.classesDeFalha,
+            produto: master.projeto.name,
+            avaliadoPor: master.avaliadoPor,
+            postmortem: `.orkastery/threads/${thread.id}/POSTMORTEM.json`,
+        },
+    });
+}
+/** Grava a origem da thread na colecao `roadmap` (de onde ela veio, e por que). */
+function gravarOrigemDaThread(memoria, manifesto, thread, origem) {
+    return memoria.gravar({
+        collection: 'roadmap',
+        content: `Thread ${thread.id} ("${thread.nome}") aberta no produto ${thread.projeto.name}.\n` +
+            `Origem: ${origem.tipo}${origem.referencia ? ` ${origem.referencia}` : ''}.\n` +
+            `${origem.detalhe}\n` +
+            `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}`],
+        },
+        priority: 'medium',
+        metadata: {
+            thread: thread.id,
+            origem: origem.tipo,
+            referencia: origem.referencia,
+            produto: thread.projeto.name,
+        },
+    });
+}
+/**
+ * Grava a proposta de ajuste de um achado de auditoria na colecao `roadmap`.
+ *
+ * E o mesmo bloco obrigatorio do B5 (impacto, fix, estimativa, passo irreversivel), agora
+ * enderecado ao roadmap do produto pela memoria em vez de so pelo board em arquivo.
+ */
+function gravarPropostaDeAuditoria(memoria, manifesto, achado) {
+    const p = achado.proposta;
+    return memoria.gravar({
+        collection: 'roadmap',
+        content: `Proposta do achado ${achado.id} (${achado.pack}/${achado.regra}, severidade ${achado.severidade}) ` +
+            `para o roadmap de ${p.destino}.\n` +
+            `Titulo: ${achado.titulo}\n` +
+            `Evidencia: ${achado.arquivo}${achado.linha ? `:${achado.linha}` : ''}\n` +
+            `Impacto: ${p.impacto}\nFix: ${p.fix}\nEstimativa: ${p.estimativa}\n` +
+            `Passo irreversivel: ${p.passoIrreversivel || '(nenhum)'}\n` +
+            `Claim do auditor: ${achado.claim.alegacao} (verificar com: ${achado.claim.verificar.join(' && ') || 'sem comando'})`,
+        tags: {
+            ...tagsDoProjeto(manifesto),
+            skill: [skillDaColecao('roadmap')],
+            situation: [
+                `achado:${achado.id}`,
+                `rodada:${achado.rodada}`,
+                `pack:${achado.pack}`,
+                `regra:${achado.regra}`,
+                `severidade:${achado.severidade}`,
+            ],
+        },
+        priority: achado.severidade === 'critico' ? 'high' : 'medium',
+        metadata: {
+            achado: achado.id,
+            rodada: achado.rodada,
+            pack: achado.pack,
+            regra: achado.regra,
+            severidade: achado.severidade,
+            destino: p.destino,
+            arquivo: achado.arquivo,
+            linha: achado.linha,
+        },
+    });
+}
+// ---------------------------------------------------------------------------
+// Leitura: injecao deterministica por tag na montagem de prompt.
+// ---------------------------------------------------------------------------
+/**
+ * Le um campo de identidade de uma entrada, na ordem em que ele sobrevive ao transporte.
+ *
+ * O CLI do OrkMind grava colecao, conteudo, tags, prioridade, escopo e origem, e NAO tem
+ * canal de metadata. Um leitor que dependesse so de `metadata` funcionaria com o driver
+ * em memoria e falharia contra o OrkMind de verdade, exatamente onde importa. Por isso a
+ * identidade viaja em tres lugares, e a leitura tenta os tres:
+ *
+ *   1. `metadata` (drivers que a carregam, como a API e o driver de teste);
+ *   2. a tag `situation` no formato `<campo>:<valor>` (busca por tag e exata);
+ *   3. uma linha `Rotulo: valor` no proprio conteudo (proveniencia declarada em texto).
+ */
+function daMetadata(e, campo) {
+    const bruto = e.metadata?.[campo];
+    return typeof bruto === 'string' && bruto !== '' ? bruto : null;
+}
+function daTag(e, prefixo) {
+    const achada = (e.tags.situation ?? []).find((t) => t.startsWith(`${prefixo}:`));
+    return achada ? achada.slice(prefixo.length + 1) : null;
+}
+function doConteudo(e, rotulo) {
+    const linha = e.content.split('\n').find((l) => l.trim().startsWith(`${rotulo}:`));
+    return linha ? linha.trim().slice(rotulo.length + 1).trim() : null;
+}
+/** Id da decisao (`D1`) que originou a entrada, ou null. */
+function decisaoDaEntrada(e) {
+    return daMetadata(e, 'decisao') ?? daTag(e, 'decisao');
+}
+/** Thread de origem da entrada, ou null. */
+function threadDaEntrada(e) {
+    return daMetadata(e, 'thread') ?? daTag(e, 'thread');
+}
+/** Arquivo commitado do handoff publicado, ou null. */
+function arquivoDoHandoff(e) {
+    return daMetadata(e, 'arquivo') ?? doConteudo(e, 'Arquivo commitado');
+}
+/** POSTMORTEM commitado da licao publicada, ou null. */
+function postmortemDaLicao(e) {
+    return daMetadata(e, 'postmortem') ?? doConteudo(e, 'Postmortem');
+}
+/** As decisoes fechadas da thread na memoria semantica. */
+function decisoesDaThreadNaMemoria(memoria, manifesto, thread) {
+    return memoria.buscar({
+        collection: 'decision',
+        tags: {
+            project: tagsDoProjeto(manifesto).project,
+            skill: [skillDaColecao('decision')],
+            situation: [situacaoDaThread(thread.id)],
+        },
+    });
+}
+/**
+ * As licoes das threads ANTERIORES do mesmo produto.
+ *
+ * A thread corrente e excluida de proposito: uma thread nao aprende consigo mesma antes
+ * de ter fechado, e repetir a propria licao no GOAL so gasta janela.
+ */
+function licoesDoProduto(memoria, manifesto, threadCorrente, limite = 5) {
+    const todas = memoria.buscar({
+        collection: 'learning',
+        tags: {
+            project: tagsDoProjeto(manifesto).project,
+            skill: [skillDaColecao('learning')],
+        },
+    });
+    return todas.filter((e) => threadDaEntrada(e) !== threadCorrente).slice(0, limite);
+}
+/** As regras publicadas do projeto (policies e o que o humano marcou como mandatory). */
+function regrasDoProjeto(memoria, manifesto) {
+    return memoria.buscar({
+        collection: 'rule',
+        tags: { project: tagsDoProjeto(manifesto).project },
+    });
+}
+/** A primeira linha util de um conteudo, usada como titulo do item injetado. */
+function primeiraLinha(texto) {
+    return texto.split('\n').find((l) => l.trim() !== '')?.trim() ?? texto.slice(0, 80);
+}
+/**
+ * Monta o bloco de memoria do prompt de uma fase.
+ *
+ * O contrato que o B6 precisa cumprir, e que o teste cobra:
+ *
+ *  - TODA decisao fechada (`locked`) da thread entra, em qualquer regime. Em `files` a
+ *    fonte e o `thread.json`; em `orkmind` e a uniao do `thread.json` com a colecao
+ *    `decision`, deduplicada por id da decisao. Uniao, e nao troca, porque uma gravacao
+ *    que falhou no OrkMind nao pode fazer a decisao sumir do prompt.
+ *  - No GOAL, entram as licoes das threads anteriores do produto (`learning`).
+ *  - Entradas `mandatory` do OrkMind entram sempre que as tags casam, em qualquer fase.
+ *  - Todo item declara a proveniencia: `path#ancora` ou `orkmind://<colecao>/<id>`.
+ */
+function injecaoDaFase(carregado, memoria, thread, fase) {
+    const { manifesto } = carregado;
+    const itens = [];
+    const caminhoThread = `.orkastery/threads/${thread.id}/thread.json`;
+    let n = 0;
+    const add = (item) => {
+        n += 1;
+        itens.push({ id: `inj-${n}`, ...item });
+    };
+    // 1. Decisoes fechadas da thread. A fonte em arquivo vem primeiro porque ela e a que
+    // existe em qualquer regime; a memoria semantica completa o que o arquivo nao tem.
+    const vistas = new Set();
+    for (const d of thread.decisoes ?? []) {
+        if (!d.locked)
+            continue;
+        vistas.add(d.id);
+        add({
+            colecao: 'decision',
+            titulo: `Decisao ${d.id} (fechada por ${d.decididaPor})`,
+            conteudo: d.texto,
+            origem: 'thread.json',
+            location: `${caminhoThread}#json:decisoes.${d.id}`,
+            mandatory: false,
+        });
+    }
+    if (memoria.ativo) {
+        for (const e of decisoesDaThreadNaMemoria(memoria, manifesto, thread)) {
+            const id = decisaoDaEntrada(e);
+            if (id && vistas.has(id))
+                continue;
+            if (id)
+                vistas.add(id);
+            add({
+                colecao: 'decision',
+                titulo: id ? `Decisao ${id} (memoria semantica)` : 'Decisao fechada (memoria semantica)',
+                conteudo: e.content,
+                origem: 'orkmind',
+                location: (0, orkmind_1.enderecoDeMemoria)('decision', e.id),
+                mandatory: e.mandatory,
+            });
+        }
+    }
+    const decisoes = itens.length;
+    // 2. Licoes das threads anteriores do produto: entram no GOAL, que e onde o objetivo
+    // ainda pode mudar por causa delas.
+    let licoes = 0;
+    if (memoria.ativo && fase === 'GOAL') {
+        for (const e of licoesDoProduto(memoria, manifesto, thread.id)) {
+            licoes += 1;
+            add({
+                colecao: 'learning',
+                titulo: `Licao da thread ${threadDaEntrada(e) ?? '(anterior)'}`,
+                conteudo: e.content,
+                origem: 'orkmind',
+                location: (0, orkmind_1.enderecoDeMemoria)('learning', e.id),
+                mandatory: e.mandatory,
+            });
+        }
+    }
+    // 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;
+    if (memoria.ativo) {
+        for (const e of regrasDoProjeto(memoria, manifesto)) {
+            if (!e.mandatory)
+                continue;
+            regras += 1;
+            add({
+                colecao: 'rule',
+                titulo: `Regra mandatoria: ${primeiraLinha(e.content).slice(0, 70)}`,
+                conteudo: e.content,
+                origem: 'orkmind',
+                location: (0, orkmind_1.enderecoDeMemoria)('rule', e.id),
+                mandatory: true,
+            });
+        }
+    }
+    return {
+        regime: memoria.regime,
+        fase,
+        thread: thread.id,
+        itens,
+        decisoes,
+        licoes,
+        regras,
+        texto: textoDaInjecao(itens, memoria.regime),
+    };
+}
+/**
+ * O texto exato que vai para `{{memoria_injetada}}` no template da fase.
+ *
+ * Vazio quando nao ha item: a linha da variavel some do prompt e o texto fica byte a byte
+ * igual ao que o B4 ja despachava. Uma thread sem decisao fechada nao ganha secao vazia.
+ */
+function textoDaInjecao(itens, regime) {
+    if (itens.length === 0)
+        return '';
+    const linhas = [];
+    linhas.push('');
+    linhas.push(`## Memoria injetada (regime ${regime})`);
+    linhas.push('Recuperacao deterministica por tag. Todo item declara de onde veio: nada entra neste ' +
+        'prompt sem proveniencia. O que NAO esta aqui esta nos ponteiros do handoff, ' +
+        'recuperavel por `ork recall`.');
+    const porColecao = {};
+    for (const i of itens)
+        (porColecao[i.colecao] ??= []).push(i);
+    const rotulos = {
+        decision: 'Decisoes fechadas desta thread (entram em TODA fase)',
+        learning: 'Licoes de threads anteriores deste produto',
+        rule: 'Regras mandatorias do ecossistema',
+        handoff: 'Handoffs anteriores',
+        roadmap: 'Roadmap',
+    };
+    for (const colecao of ['decision', 'learning', 'rule', 'handoff', 'roadmap']) {
+        const doGrupo = porColecao[colecao];
+        if (!doGrupo || doGrupo.length === 0)
+            continue;
+        linhas.push('');
+        linhas.push(`### ${rotulos[colecao] ?? colecao} (${doGrupo.length})`);
+        for (const i of doGrupo) {
+            linhas.push(`- ${i.titulo}${i.mandatory ? ' [MANDATORY]' : ''}`);
+            for (const l of i.conteudo.split('\n')) {
+                if (l.trim() !== '')
+                    linhas.push(`  ${l}`);
+            }
+            linhas.push(`  origem: ${i.location}`);
+        }
+    }
+    return linhas.join('\n');
+}
+/** Caminho relativo do handoff da thread, o mesmo endereco que vai no ponteiro. */
+function caminhoRelativoDoHandoff(raiz, threadId) {
+    const abs = `${(0, thread_1.dirThread)(raiz, threadId)}/handoff.json`;
+    return abs.startsWith(raiz) ? abs.slice(raiz.length + 1) : abs;
+}
+/**
+ * `ork memory sync`: publica na memoria semantica o que a thread ja fechou.
+ *
+ * Idempotente por construcao: o driver grava com `--dedupe`, entao rodar o sync duas
+ * 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) {
+    const { raiz, manifesto } = carregado;
+    const vazio = juntar([], memoria.regime);
+    let decisoes = vazio;
+    let handoff = null;
+    let learning = null;
+    let roadmap = null;
+    const policies = gravarPolicies(memoria, manifesto);
+    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}".`,
+        });
+        const caminhoDoHandoff = path.join((0, thread_1.dirThread)(raiz, threadId), 'handoff.json');
+        if (fs.existsSync(caminhoDoHandoff)) {
+            const pacote = (0, util_1.lerJson)(caminhoDoHandoff);
+            handoff = gravarHandoff(memoria, manifesto, thread, pacote, caminhoRelativoDoHandoff(raiz, threadId));
+        }
+        // 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);
+        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;
+    return {
+        regime: memoria.regime,
+        estado: memoria.estado,
+        thread: threadId,
+        decisoes,
+        policies,
+        handoff,
+        learning,
+        roadmap,
+        total,
+        falhas,
+    };
+}
+/**
+ * Gancho unico de publicacao usado pelos comandos do CLI.
+ *
+ * Ele existe para que `thread new`, `master` e `audit` chamem UMA linha cada, e para que
+ * nenhum deles precise saber se ha OrkMind ligado: em regime `files` a funcao devolve o
+ * resultado dizendo que nada foi gravado, e o comando segue igual.
+ */
+function publicar(carregado, threadId, origem, memoriaAberta) {
+    const memoria = memoriaAberta ?? abrirMemoria(carregado);
+    const r = sincronizarMemoria(carregado, memoria, threadId, origem);
+    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',
+            regime: memoria.regime,
+            tenant: memoria.estado.tenant,
+            decisoes: r.decisoes.gravadas.length,
+            policies: r.policies.gravadas.length,
+            handoff: r.handoff?.id ?? null,
+            learning: r.learning?.id ?? null,
+            roadmap: r.roadmap?.id ?? null,
+            falhas: r.falhas,
+        });
+    }
+    return r;
+}
+/**
+ * Publica as propostas de achados de auditoria na colecao `roadmap`.
+ *
+ * O mesmo bloco obrigatorio do B5 (impacto, fix, estimativa, passo irreversivel) sai do
+ * board em arquivo e chega ao roadmap do produto pela memoria, quando ela esta ligada.
+ */
+function publicarPropostas(carregado, achados, memoriaAberta) {
+    const memoria = memoriaAberta ?? abrirMemoria(carregado);
+    const resultados = achados.map((a) => gravarPropostaDeAuditoria(memoria, carregado.manifesto, a));
+    return juntar(resultados, memoria.regime);
+}
+/** Texto de `ork memory status`. */
+function textoDoEstado(estado) {
+    const linhas = [];
+    linhas.push('Regime de memoria do projeto');
+    linhas.push('');
+    linhas.push(`  pedido no manifesto   ${estado.pedido}`);
+    linhas.push(`  regime efetivo        ${estado.efetivo}`);
+    linhas.push(`  tenant                ${estado.tenant}`);
+    linhas.push(`  variavel da base      ${estado.variavel || '(nao declarada)'}`);
+    linhas.push(`  DSN no ambiente       ${estado.dsnPresente ? 'sim (valor nunca impresso)' : 'nao'}`);
+    linhas.push(`  cli do OrkMind        ${estado.cli}`);
+    linhas.push('');
+    if (estado.motivo) {
+        linhas.push(`  degradacao: ${estado.motivo}`);
+        linhas.push(`    ${estado.detalhe}`);
+        linhas.push(`    correcao: ${estado.correcao}`);
+        linhas.push('');
+        linhas.push('  O ciclo NAO para por isso: em regime files o handoff continua triado em 3 niveis,');
+        linhas.push('  os ponteiros continuam `path#ancora` e `ork recall` continua resolvendo.');
+    }
+    else {
+        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.');
+    }
+    return linhas.join('\n');
+}
+/** Texto de `ork memory sync`. */
+function textoDoSync(r) {
+    const linhas = [];
+    linhas.push(`Sincronizacao de memoria (regime ${r.regime})${r.thread ? ` da thread ${r.thread}` : ''}`);
+    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);
+    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)'}`);
+    };
+    um('handoff', r.handoff);
+    um('learning', r.learning);
+    um('roadmap', r.roadmap);
+    linhas.push('');
+    linhas.push(`  total ${r.total} tentativa(s), ${r.falhas} sem gravacao`);
+    if (r.regime === 'files') {
+        linhas.push('');
+        linhas.push(`  ${r.estado.detalhe}`);
+        linhas.push(`  correcao: ${r.estado.correcao}`);
+    }
+    return linhas.join('\n');
+}
+/** Prioridade valida a partir de texto livre, com o padrao do OrkMind. */
+function parsePrioridade(bruto) {
+    const validas = ['critical', 'high', 'medium', 'low'];
+    if (!bruto)
+        return 'medium';
+    const limpo = bruto.trim().toLowerCase();
+    return validas.includes(limpo) ? limpo : null;
+}