dd-harness-mcp 0.13.0 → 0.15.0

package/dist/cli/src/cinto.js

@@ -25,19 +25,55 @@ 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 = {
         gravado_em: new Date().toISOString(),
         memorias: brain.memorias
             .filter((m) => m.status === "ativa" && m.ancoras.length > 0)
-            .map(({ pasta, slug, titulo, resumo, status, ancoras }) => ({
+            .map(({ pasta, slug, titulo, resumo, status, ancoras, escopo }) => ({
             pasta,
             slug,
             titulo,
             resumo,
             status,
             ancoras,
+            escopo,
         })),
     };
     try {
@@ -108,7 +144,7 @@ export function caminhoRelativo(raiz, arquivo) {
  * Vazio e o caso comum e tem que sair barato: a maioria das edicoes nao toca ancora
  * alguma, e o silencio ai nao e falta de aviso, e a ausencia de motivo para avisar.
  */
-export function alerta(tocadas, resumos) {
+export function alerta(tocadas, resumos, globais = new Set()) {
     if (tocadas.length === 0)
         return "";
     const linhas = [
@@ -117,7 +153,11 @@ export function alerta(tocadas, resumos) {
     ];
     for (const t of tocadas) {
         const endereco = `${t.pasta}/${t.memoria}`;
-        linhas.push(`## ${t.titulo}`, `\`${endereco}\` — âncora: \`${t.ancora}\``, "");
+        // Marcar a global muda o peso do que se le: a licao nao fala DESTE projeto, fala de
+        // todos. Sem a marca, o agente a avalia como decisao local e pode concluir que "aqui
+        // e diferente" — que e exatamente o raciocinio que a promocao existiu para vencer.
+        const marca = globais.has(endereco) ? " · MEMÓRIA GLOBAL" : "";
+        linhas.push(`## ${t.titulo}${marca}`, `\`${endereco}\` — âncora: \`${t.ancora}\``, "");
         const resumo = resumos.get(endereco);
         if (resumo)
             linhas.push(resumo, "");
@@ -168,11 +208,12 @@ export async function decideDoHook(entrada) {
     if (novas.length === 0)
         return permitir;
     const resumos = new Map(cache.memorias.map((m) => [`${m.pasta}/${m.slug}`, m.resumo]));
+    const globais = new Set(cache.memorias.filter((m) => m.escopo === "global").map((m) => `${m.pasta}/${m.slug}`));
     return JSON.stringify({
         hookSpecificOutput: {
             hookEventName: "PreToolUse",
             permissionDecision: "allow",
-            additionalContext: alerta(novas, resumos),
+            additionalContext: alerta(novas, resumos, globais),
         },
     });
 }

package/dist/cli/src/curar.js

@@ -92,3 +92,52 @@ export async function arquiva(raiz, endereco, opcoes) {
     const lido = (await resposta.json());
     return lido;
 }
+/**
+ * Promove a memoria a global — ou a traz de volta ao projeto de origem.
+ *
+ * Global vale para TODO projeto do espaco, inclusive os que ainda nao existem. E o degrau
+ * acima de `memory_projects`, que lista projetos nomeados: aqui o alcance deixa de ser
+ * uma lista e vira uma propriedade.
+ */
+export async function promove(raiz, endereco, global) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}/escopo`, {
+        method: "PUT",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({ tenant: config.tenant, projeto: config.projeto, global }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}
+/**
+ * Apaga de verdade, em cascata — ancoras, deriva medida, vinculos, tudo.
+ *
+ * Diferente de `arquiva`, que e o caminho normal: arquivar guarda o conteudo porque o que
+ * a memoria dizia pode voltar a importar. Isto e para o que nunca deveria ter existido.
+ *
+ * Sem `confirmacao`, o servidor RECUSA e devolve o que a cascata levaria junto — e so
+ * entao se repete a chamada com o nome do espaco. Duas etapas de proposito: DELETE nao
+ * tem desfazer, e a cascata e invisivel de fora.
+ */
+export async function apaga(raiz, endereco, confirmacao) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}/apagar`, {
+        method: "POST",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            ...(confirmacao ? { confirmacao } : {}),
+        }),
+    });
+    // 409 aqui nao e falha: e "ainda nao" — falta confirmar, ou ha uma arquivada apontando
+    // para esta. O texto do servidor e a resposta, entao ele passa adiante em vez de virar
+    // excecao com mensagem generica.
+    if (resposta.status === 409) {
+        const lido = (await resposta.json());
+        return { apagou: false, detalhe: lido.erro, confirmacaoEsperada: lido.confirmacao_esperada };
+    }
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}

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/cli/src/index.js

@@ -22,7 +22,7 @@ import { buscaPolitica } from "./politica.js";
 import { avisoDeOrdem, blocoDeSessao, criaFase, editaFase, formataChangelog, formataRoadmap, leFases, } from "./roadmap.js";
 import { decideDoHook, guardaCache } from "./cinto.js";
 import { busca } from "./buscar.js";
-import { arquiva, edita, le } from "./curar.js";
+import { apaga, arquiva, edita, le, promove } from "./curar.js";
 import { criaPasta } from "./pasta.js";
 import { criaProjeto, listaTenants } from "./projeto.js";
 import { reancora } from "./reancorar.js";
@@ -52,6 +52,15 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
   dd-harness arquivar <pasta>/<slug> --motivo <obsoleta|incorreta|fora_dos_filtros>
                      [--substituida-por <pasta>/<slug>]
                                      tira de circulação sem apagar
+  dd-harness promover <pasta>/<slug>
+                                     torna a memória global: vale para TODO
+                                     projeto do espaço, inclusive os futuros
+  dd-harness despromover <pasta>/<slug>
+                                     traz de volta ao alcance dos vínculos
+  dd-harness apagar <pasta>/<slug> [--confirmar <espaço>]
+                                     apaga de vez, em cascata — sem desfazer.
+                                     Para tirar de circulação guardando o
+                                     conteúdo, use "arquivar"
   dd-harness buscar "<pergunta>"     acha memória por relevância, não por arquivo
   dd-harness ler <pasta>/<slug>      imprime a memória inteira, no formato de gravar
   dd-harness reancorar <pasta>/<slug> --de "<alvo>" --para "<alvo>"
@@ -180,6 +189,10 @@ async function comandoFase(argv) {
  * primeira conexao do Claude Code. Sem isto, a primeira instalacao acontecia so quando
  * o host tentava conectar ao servidor MCP, e o handshake tem timeout curto demais para
  * esperar o download: a sessao real via `CONNECTION_CLOSED` em vez de "instalando".
+ *
+ * Roda em TODO `start`, nao so no primeiro: e tambem o ponto em que o cache do npx e
+ * renovado para a versao mais recente. Um projeto ja configurado que roda `start` de novo
+ * sai dali com CLI e MCP frescos, sem ninguem precisar lembrar de atualizar nada.
  */
 function instalaMcp() {
     return new Promise((resolve) => {
@@ -187,7 +200,14 @@ function instalaMcp() {
         // segundos) e, se falhar, ve POR QUE — em vez do "nao consegui" mudo que nao dava
         // pista nenhuma para diagnosticar. O DEP0190 que isto dispara e suprimido no topo
         // do arquivo (`process.removeAllListeners("warning")`).
-        const p = spawn("npx", ["-y", "dd-harness-mcp", "--help"], {
+        //
+        // `@latest` EXPLICITO, e nao `dd-harness-mcp` pelado: sem a tag, o npx serve a copia
+        // que ja estiver no cache dele e nem consulta o registro. Medido na rodada 006 — a
+        // cobaia rodou uma sessao inteira contra um MCP defasado sem nada denunciar. O
+        // `.mcp.json` continua declarando o pacote SEM versao, de proposito: o que precisa
+        // estar fresco e o cache, e fixar versao no arquivo obrigaria a reescrever config em
+        // todo repositorio a cada publicacao.
+        const p = spawn("npx", ["-y", "dd-harness-mcp@latest", "--help"], {
             shell: process.platform === "win32",
             stdio: "inherit",
         });
@@ -221,6 +241,32 @@ async function versaoDesatualizada() {
         return null;
     }
 }
+/**
+ * Instala a versao mais nova do CLI globalmente, de dentro do proprio wizard.
+ *
+ * Ate aqui o `start` so AVISAVA e mandava o usuario rodar `npm i -g` e recomecar — e
+ * "comece de novo" no meio de um wizard e o tipo de instrucao que ninguem segue. A
+ * rodada 006 mostrou o custo: a sessao inteira rodou contra um CLI defasado, com o
+ * relatorio registrando "ja instalado, nao atualizado" como se fosse normal.
+ *
+ * O binario EM EXECUCAO continua sendo o antigo ate este processo terminar — nao ha como
+ * trocar codigo de baixo de si mesmo. Isso e seguro aqui porque o que resta do wizard so
+ * escreve configuracao (JSON e markdown), nada que dependa de correcao nova; e do
+ * proximo comando em diante tudo ja e a versao nova.
+ *
+ * Nunca lanca: falhar em atualizar nao pode travar o `start`. Sem permissao para escrever
+ * no diretorio global (o caso mais comum), o wizard segue e o aviso continua valendo.
+ */
+function atualizaCli(ultima) {
+    return new Promise((resolve) => {
+        const p = spawn("npm", ["install", "-g", `dd-harness@${ultima}`], {
+            shell: process.platform === "win32",
+            stdio: "inherit",
+        });
+        p.on("exit", (code) => resolve(code === 0));
+        p.on("error", () => resolve(false));
+    });
+}
 /**
  * Tenta abrir o navegador padrao. Nunca lanca — falhar em abrir nao pode travar o
  * wizard, so degrada para "aqui esta a URL, abra voce mesmo".
@@ -271,9 +317,14 @@ async function comandoStart() {
     // pre-instalacao do MCP, passo 5.5 abaixo, numa versao anterior a ela existir).
     const desatualizado = await versaoDesatualizada();
     if (desatualizado) {
-        console.log(`AVISO: você está na versão ${desatualizado.atual}, e a mais recente é ` +
-            `${desatualizado.ultima}. Rode \`npm install -g dd-harness@latest\` e comece de ` +
-            "novo — start segue mesmo assim, mas pode faltar correção.\n");
+        console.log(`Atualizando o dd-harness: ${desatualizado.atual} → ${desatualizado.ultima}...`);
+        const atualizou = await atualizaCli(desatualizado.ultima);
+        console.log(atualizou
+            ? `Pronto — ${desatualizado.ultima} instalada. O wizard segue na ${desatualizado.atual} ` +
+                "(o binário em execução não troca sozinho); do próximo comando em diante, a nova.\n"
+            : `Não consegui atualizar — o npm explicou o motivo acima. Você segue na ` +
+                `${desatualizado.atual}, e a mais recente é ${desatualizado.ultima}: rode ` +
+                "`npm install -g dd-harness@latest` quando puder. O start continua assim mesmo.\n");
     }
     // 1. Credencial. Sem ela nada do resto e possivel — nem listar tenant.
     // O estado aparece SEMPRE, mesmo quando ja existe credencial: antes o passo era
@@ -366,7 +417,8 @@ async function comandoStart() {
         }[mcp.estado]);
     }
     if (mcp.ok) {
-        console.log("\nInstalando o servidor dd-harness-mcp (primeira vez pode demorar um pouco)...");
+        console.log("\nInstalando a versão mais recente do servidor dd-harness-mcp " +
+            "(a primeira vez pode demorar um pouco)...");
         const { ok: instalou, erro: erroInstalacao } = await instalaMcp();
         console.log(instalou
             ? "dd-harness-mcp instalado — a próxima sessão do Claude Code conecta na hora."
@@ -477,6 +529,49 @@ async function comandoEditar(argv) {
     console.log(`  ${r.ancoras} âncora(s).`);
 }
 const MOTIVOS = ["obsoleta", "incorreta", "fora_dos_filtros"];
+/**
+ * `promover` / `despromover` — o alcance da memoria.
+ *
+ * Global vale para TODO projeto do espaco, inclusive os que ainda nao existem. Nao e o
+ * mesmo que `projetos:` no frontmatter, que lista projetos nomeados: la o alcance e uma
+ * lista, aqui e uma propriedade.
+ */
+async function comandoPromover(argv, global) {
+    const endereco = argv[0];
+    const verbo = global ? "promover" : "despromover";
+    if (!endereco || endereco.startsWith("-") || !endereco.includes("/")) {
+        throw new Error(`uso: dd-harness ${verbo} <pasta>/<slug>`);
+    }
+    const r = await promove(process.cwd(), endereco, global);
+    console.log(global
+        ? `${endereco} agora é GLOBAL — vale para todo projeto de ${r.tenant}, inclusive os que ainda não existem.`
+        : `${endereco} voltou a valer só para os projetos a que está vinculada.`);
+}
+/**
+ * `apagar` — o unico caminho que destroi.
+ *
+ * Duas etapas, e a segunda pede o nome do espaco digitado. Nao e cerimonia: a cascata leva
+ * ancoras e toda a deriva medida delas, e nao ha desfazer. Arquivar continua sendo o
+ * caminho normal — isto e para o que nunca deveria ter existido.
+ */
+async function comandoApagar(argv) {
+    const endereco = argv[0];
+    if (!endereco || endereco.startsWith("-") || !endereco.includes("/")) {
+        throw new Error("uso: dd-harness apagar <pasta>/<slug> [--confirmar <espaço>]");
+    }
+    const r = await apaga(process.cwd(), endereco, argumento(argv, "confirmar"));
+    if (!r.apagou) {
+        console.log(r.detalhe);
+        if (r.confirmacaoEsperada) {
+            console.log(`
+  dd-harness apagar ${endereco} --confirmar ${r.confirmacaoEsperada}`);
+        }
+        // Sem exit diferente de zero: recusar por falta de confirmacao nao e falha, e o
+        // caminho normal da primeira chamada.
+        return;
+    }
+    console.log(`${endereco} apagada — ${r.detalhe}`);
+}
 async function comandoArquivar(argv) {
     const endereco = argv[0];
     const motivo = argumento(argv, "motivo");
@@ -952,6 +1047,12 @@ async function principal() {
             return comandoEditar(resto);
         case "arquivar":
             return comandoArquivar(resto);
+        case "promover":
+            return comandoPromover(resto, true);
+        case "despromover":
+            return comandoPromover(resto, false);
+        case "apagar":
+            return comandoApagar(resto);
         case "ler":
             return comandoLer(resto);
         case "buscar":

package/dist/cli/src/init.js

@@ -17,12 +17,19 @@ export const SUGESTAO_MCP = `{
   }
 }`;
 /**
- * O hook que carrega a politica no inicio de cada sessao.
+ * Os dois hooks do dd-harness, pelas duas razoes que nenhuma instrucao em markdown
+ * resolve.
  *
- * E a garantia de que nenhuma sessao abre sem protocolo — o papel que antes era do
- * arquivo materializado mais a linha de import. Vive num hook, e nao numa instrucao no
- * `CLAUDE.md`, porque instrucao o modelo pode pular: o import quebrado falhava em
- * silencio, e isso foi medido.
+ * `SessionStart` carrega a politica no inicio de cada sessao — a garantia de que nenhuma
+ * abre sem protocolo, papel que antes era do arquivo materializado mais a linha de
+ * import. Vive num hook, e nao numa instrucao no `CLAUDE.md`, porque instrucao o modelo
+ * pode pular: o import quebrado falhava em silencio, e isso foi medido.
+ *
+ * `PreToolUse` e o cinto: cruza o arquivo que esta sendo editado contra as ancoras e
+ * entrega a memoria ANTES da edicao. Existe porque o Brain era todo PULL, e PULL falha
+ * onde mais custa — o agente nao busca memoria quando *acha que sabe*. Os dois vao
+ * juntos aqui de proposito: quem monta o `settings.json` a mao pelo `init` sairia sem o
+ * cinto e sem nunca saber que ele existe.
  *
  * Sugerido e nao escrito, pelo mesmo motivo do `.mcp.json`.
  */
@@ -38,6 +45,17 @@ export const SUGESTAO_HOOK = `{
           }
         ]
       }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "dd-harness cinto"
+          }
+        ]
+      }
     ]
   }
 }`;

package/dist/mcp/src/index.js

@@ -6,7 +6,7 @@ import * as z from "zod/v4";
 // que e gerado por build e nao vai no git — num checkout limpo (a Vercel) a resolucao
 // falharia, e foi assim que o build de producao caiu uma vez. Aqui o compilador segue o
 // fonte, e o `dist` deste pacote sai com o codigo do CLI embutido.
-import { arquiva, edita, le } from "../../cli/src/curar.js";
+import { apaga, arquiva, edita, le, promove } from "../../cli/src/curar.js";
 import { busca } from "../../cli/src/buscar.js";
 import { criaPasta } from "../../cli/src/pasta.js";
 import { criaProjeto } from "../../cli/src/projeto.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);
@@ -218,6 +230,66 @@ Use \`substituida_por\` quando outra memória toma o lugar desta — a troca aco
             return falha(erro);
         }
     });
+    server.registerTool("promover_memoria", {
+        description: `Torna uma memória GLOBAL: ela passa a valer para todo projeto deste espaço, inclusive os que ainda não existem.
+
+PROPONHA ao humano e espere o OK. Promover não é editar — é decidir que uma lição vale para tudo que se faz aqui, e o alcance passa a incluir projetos que ninguém escreveu ainda.
+
+Quando propor: a memória descreve algo que NÃO é deste projeto — um limite de fornecedor, uma regra da organização, uma armadilha da linguagem ou da ferramenta, uma decisão que vale para tudo que você constrói. O teste: se o próximo projeto repetir este erro, a memória teria evitado?
+
+Quando NÃO propor: a memória fala de uma escolha deste projeto, de um arquivo deste repositório, de um acordo com um cliente específico. Isso é memória de projeto — e para alcançar alguns projetos nomeados existe \`projetos:\` no frontmatter, que é uma lista, não uma propriedade.
+
+\`global: false\` traz de volta. É reversível, e a memória nunca sai da pasta onde nasceu: a origem é metade do porquê.`,
+        inputSchema: z.object({
+            endereco: z.string().min(1).describe("`<pasta>/<slug>` da memória."),
+            global: z
+                .boolean()
+                .default(true)
+                .describe("`true` promove a global; `false` traz de volta ao alcance dos vínculos."),
+        }),
+    }, async ({ endereco, global }) => {
+        try {
+            const r = await promove(raiz, endereco, global);
+            return texto(global
+                ? `\`${endereco}\` agora é GLOBAL — vale para todo projeto de ${r.tenant}, ` +
+                    "inclusive os que ainda não existem. Ela continua morando na pasta onde nasceu."
+                : `\`${endereco}\` voltou a valer só para os projetos a que está vinculada.`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("apagar_memoria", {
+        description: `Apaga uma memória DE VEZ, com as âncoras e toda a deriva medida delas. Não há desfazer.
+
+Na maioria dos casos o certo é \`arquivar_memoria\`, não isto: arquivar tira do Brain ativo e guarda o conteúdo, porque o que a memória dizia pode voltar a importar. Apagar é para o que nunca deveria ter existido — a gravada por engano, a duplicata, o teste.
+
+DUAS ETAPAS. Chame primeiro SEM \`confirmacao\`: a resposta diz o que a cascata levaria junto e qual palavra digitar. Leve isso ao humano e só chame de novo com a confirmação se ele disser para apagar. Nunca invente a confirmação para pular a pergunta — a etapa existe para que uma pessoa veja o custo antes.`,
+        inputSchema: z.object({
+            endereco: z.string().min(1).describe("`<pasta>/<slug>` da memória."),
+            confirmacao: z
+                .string()
+                .optional()
+                .describe("O nome do espaço, exatamente como a primeira chamada informou. Só mande depois de o humano confirmar."),
+        }),
+    }, async ({ endereco, confirmacao }) => {
+        try {
+            const r = await apaga(raiz, endereco, confirmacao);
+            if (!r.apagou) {
+                return texto(`${r.detalhe}` +
+                    (r.confirmacaoEsperada
+                        ? `
+
+Pergunte ao humano antes de seguir. Se ele confirmar, repita com ` +
+                            `\`confirmacao: "${r.confirmacaoEsperada}"\`.`
+                        : ""));
+            }
+            return texto(`\`${endereco}\` apagada — ${r.detalhe}`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
     server.registerTool("criar_projeto", {
         description: `Cria um projeto no serviço — o espaço onde as pastas e memórias deste repositório vão morar.
 

package/package.json

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