dd-harness-mcp 0.13.0 → 0.14.0

package/dist/cli/src/cinto.js

@@ -25,6 +25,41 @@ import { memoriasNoConteudo } from "./diff.js";
 export function caminhoDoCache(raiz) {
     return join(raiz, ".claude", "dd-harness-ancoras.json");
 }
+/**
+ * Acrescenta UMA memoria ao cache, sem esperar a proxima sessao.
+ *
+ * Existe por um furo medido na rodada 006: o cache so era escrito pelo `SessionStart`, e
+ * memoria gravada no meio da sessao ficava invisivel ao cinto ate a sessao seguinte —
+ * justo no fluxo mais natural, que e gravar a memoria e ser avisado minutos depois se
+ * alguem tentar desfazer o que ela protege. A memoria nascia sem proteger nada.
+ *
+ * Escreve so o que ja esta na mao de quem gravou: sem rede, porque nao ha payload novo a
+ * buscar, e uma requisicao a mais no caminho de escrita nao se justifica para atualizar
+ * um cache que a proxima sessao reconstroi inteiro de qualquer jeito.
+ *
+ * Idempotente pelo endereco: regravar a mesma memoria substitui a entrada, nunca duplica.
+ */
+export async function acrescentaAoCache(raiz, memoria) {
+    if (memoria.ancoras.length === 0)
+        return;
+    const atual = (await leCache(raiz)) ?? { gravado_em: "", memorias: [] };
+    const endereco = `${memoria.pasta}/${memoria.slug}`;
+    const cache = {
+        gravado_em: new Date().toISOString(),
+        memorias: [
+            ...atual.memorias.filter((m) => `${m.pasta}/${m.slug}` !== endereco),
+            memoria,
+        ],
+    };
+    try {
+        const caminho = caminhoDoCache(raiz);
+        await mkdir(dirname(caminho), { recursive: true });
+        await writeFile(caminho, `${JSON.stringify(cache)}\n`, "utf8");
+    }
+    catch {
+        // Mesmo motivo do `guardaCache`: cache e otimizacao, nao contrato.
+    }
+}
 /** Guarda as ancoras do Brain para o hook consultar sem rede. Falha em silencio: cache e otimizacao, nao contrato. */
 export async function guardaCache(raiz, brain) {
     const cache = {

package/dist/cli/src/gravar.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { recusaPorAcentuacao } from "./acentuacao.js";
 import { cabecalhos, credencial, pede, recusa } from "./api.js";
+import { acrescentaAoCache } from "./cinto.js";
 const OBRIGATORIOS = ["name", "titulo", "description", "pasta"];
 /**
  * Frontmatter simples: `chave: valor` por linha. Sem lib de YAML — nao ha aninhamento.
@@ -188,6 +189,18 @@ export async function grava(raiz, caminho) {
     if (!resposta.ok)
         await recusa(resposta);
     const { endereco } = (await resposta.json());
+    // O cinto passa a enxergar esta memoria AGORA, nao na proxima sessao. Sem isto, a
+    // memoria recem-gravada nao protegia nada ate a sessao seguinte — medido na rodada 006,
+    // e justamente no fluxo mais comum: gravar a decisao e, minutos depois, alguem tentar
+    // desfazer o que ela guarda.
+    await acrescentaAoCache(raiz, {
+        pasta: memoria.pasta,
+        slug: memoria.slug,
+        titulo: memoria.titulo,
+        resumo: memoria.resumo,
+        status: "ativa",
+        ancoras: memoria.ancoras.map((valor) => ({ tipo: "caminho", valor, sha: null })),
+    });
     return {
         endereco,
         ancoras: memoria.ancoras.length,

package/dist/mcp/src/index.js

@@ -77,12 +77,24 @@ Os primeiros achados são os que valem: o piso barra tema alheio, mas num Brain
             // limite 10 devolvia dois tercos do Brain, e devolver quase tudo desfaz a
             // recuperacao por relevancia. Quem chama a rota direto continua com 10.
             const r = await busca(raiz, consulta, limite ?? 4);
+            // A busca responde igual com a base inteira indexada ou pela metade: memoria sem
+            // vetor some do resultado sem deixar rastro, e quem chamou conclui "nao existe".
+            // O CLI ja avisava; aqui ficava calado — e e no MCP que o silencio custa mais,
+            // porque e a porta que o agente usa sozinho, sem humano lendo a saida.
+            const fila = r.esperandoIndexacao > 0
+                ? `\n\nATENÇÃO: ${r.esperandoIndexacao} memória(s) ainda sem vetor — pode ` +
+                    "existir resposta melhor que não apareceu aqui. Rode o worker " +
+                    "(`start-worker.bat` ou `pnpm worker --uma-vez`) e busque de novo antes de " +
+                    "concluir que algo não está no Brain."
+                : "";
             if (r.achados.length === 0) {
                 return texto(`Nada pertinente no Brain para "${consulta}".` +
-                    (r.semantica ? "" : " (Busca lexical apenas: sem provedor de embedding configurado.)"));
+                    (r.semantica ? "" : " (Busca lexical apenas: sem provedor de embedding configurado.)") +
+                    fila);
             }
             const linhas = r.achados.map((a) => `- ${a.endereco} — ${a.titulo}: ${a.resumo}`);
-            return texto(`${r.achados.length} achado(s)${r.semantica ? "" : " (busca lexical apenas)"}:\n${linhas.join("\n")}`);
+            return texto(`${r.achados.length} achado(s)${r.semantica ? "" : " (busca lexical apenas)"}:\n${linhas.join("\n")}` +
+                fila);
         }
         catch (erro) {
             return falha(erro);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-harness-mcp",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "type": "module",
   "description": "Servidor MCP do dd-harness: o agente consulta e grava memoria como ferramenta, sem passar por arquivo.",
   "license": "UNLICENSED",