dd-harness-mcp 0.1.0

package/dist/cli/src/api.js

@@ -0,0 +1,69 @@
+import { leConfigDoRepo, leToken } from "./config.js";
+export async function credencial(raiz) {
+    const config = await leConfigDoRepo(raiz);
+    const token = await leToken(config.api);
+    if (!token) {
+        throw new Error(`sem credencial para ${config.api}. Rode \`dd-harness login --token <token>\`.`);
+    }
+    return { config, token };
+}
+/**
+ * O `erro` que a API devolve no corpo e mais util que o status, e e o que o agente le.
+ * Sem corpo interpretavel, o status ao menos diz que houve resposta.
+ */
+export async function recusa(resposta) {
+    const { erro } = (await resposta.json().catch(() => ({})));
+    throw new Error(erro ?? `a API respondeu ${resposta.status}.`);
+}
+export function cabecalhos(token, comCorpo = false) {
+    return comCorpo
+        ? { Authorization: `Bearer ${token}`, "Content-Type": "application/json" }
+        : { Authorization: `Bearer ${token}` };
+}
+/**
+ * `fetch` com nova tentativa para falha transitoria.
+ *
+ * Medido em uso real: um `ECONNRESET` de conexao ociosa derrubou um `arquivar` que
+ * funcionou na segunda tentativa manual. Sem retry, falha de rede de um segundo vira erro
+ * final — e para um agente isso e a diferenca entre seguir sozinho e parar para pedir
+ * ajuda. Com varios agentes concorrendo, transitorio deixa de ser raro.
+ *
+ * O que NAO e repetido, e o cuidado que importa:
+ *
+ * - Erro de aplicacao (4xx). Token invalido ou memoria fora dos filtros nao melhora na
+ *   segunda tentativa; repetir so atrasa a mensagem que o agente precisa ler.
+ * - 5xx em requisicao que ESCREVE. `POST /memorias` pode ter gravado antes de a resposta
+ *   se perder, e repetir criaria duas. Perder a resposta de uma escrita que funcionou e
+ *   ruim; gravar duas vezes e pior.
+ *
+ * Entao: repete falha de REDE (o `fetch` nem chegou a receber resposta) sempre, e 5xx
+ * apenas quando o metodo e seguro de repetir.
+ */
+const IDEMPOTENTES = new Set(["GET", "HEAD", "PUT", "DELETE"]);
+const espera = (ms) => new Promise((r) => setTimeout(r, ms));
+export async function pede(url, init = {}, tentativas = 3) {
+    const metodo = (init.method ?? "GET").toUpperCase();
+    const podeRepetirErroDoServidor = IDEMPOTENTES.has(metodo);
+    let ultimoErro;
+    for (let tentativa = 1; tentativa <= tentativas; tentativa += 1) {
+        try {
+            const resposta = await fetch(url, init);
+            if (resposta.status >= 500 && podeRepetirErroDoServidor && tentativa < tentativas) {
+                await espera(tentativa * 400);
+                continue;
+            }
+            return resposta;
+        }
+        catch (erro) {
+            // Aqui o `fetch` falhou antes de qualquer resposta: DNS, conexao recusada,
+            // ECONNRESET. Nada foi processado do outro lado, entao repetir e seguro mesmo
+            // para POST.
+            ultimoErro = erro;
+            if (tentativa === tentativas)
+                break;
+            await espera(tentativa * 400);
+        }
+    }
+    const detalhe = ultimoErro instanceof Error ? ultimoErro.message : String(ultimoErro);
+    throw new Error(`não consegui falar com o serviço depois de ${tentativas} tentativas: ${detalhe}`);
+}

package/dist/cli/src/artefato.js

@@ -0,0 +1,42 @@
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+/**
+ * O `GET` devolve o payload inteiro (politica, briefing, pastas e memorias); aqui so o
+ * artefato pedido interessa.
+ *
+ * `null` e `""` significam a mesma coisa para quem le — "ainda nao existe" —, e a diferenca
+ * entre elas e detalhe de como a linha foi parar no banco. Quem chama recebe `existe`, que
+ * e a pergunta real.
+ */
+export async function leArtefato(raiz, tipo) {
+    const { config, token } = await credencial(raiz);
+    const url = new URL(`${config.api}/api/v1/artefatos`);
+    url.searchParams.set("tenant", config.tenant);
+    url.searchParams.set("projeto", config.projeto);
+    const resposta = await pede(url, { headers: cabecalhos(token) });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const payload = (await resposta.json());
+    const conteudo = typeof payload[tipo] === "string" ? payload[tipo] : "";
+    return { conteudo, existe: conteudo.length > 0 };
+}
+/**
+ * Substituicao total, nao append: quem quer acrescentar um paragrafo le, concatena e
+ * reenvia. Conteudo vazio e valido e significa "apagar" — a linha fica no banco, guardando
+ * quem mexeu por ultimo.
+ */
+export async function escreveArtefato(raiz, tipo, conteudo) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/artefatos`, {
+        method: "PUT",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            tipo,
+            conteudo,
+        }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}

package/dist/cli/src/buscar.js

@@ -0,0 +1,15 @@
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+export async function busca(raiz, consulta, limite) {
+    const { config, token } = await credencial(raiz);
+    const url = new URL(`${config.api}/api/v1/busca`);
+    url.searchParams.set("tenant", config.tenant);
+    url.searchParams.set("projeto", config.projeto);
+    url.searchParams.set("q", consulta);
+    if (limite)
+        url.searchParams.set("limite", String(limite));
+    const resposta = await pede(url, { headers: cabecalhos(token) });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const lido = (await resposta.json());
+    return { semantica: lido.semantica, provedor: lido.provedor, achados: lido.resultados };
+}

package/dist/cli/src/check.js

@@ -0,0 +1,114 @@
+import { pede } from "./api.js";
+import { leConfigDoRepo, leToken } from "./config.js";
+import { caminhosDoCommit, memoriasTocadas } from "./diff.js";
+import { mede } from "./medir.js";
+/** Separado do IO para poder ser testado sem rede: dado um Brain, o que se mede. */
+export async function medeAsAncoras(raiz, brain) {
+    const medicoes = [];
+    for (const memoria of brain.memorias) {
+        // Memória arquivada não interessa: ela já saiu de circulação, e medir o alvo dela
+        // encheria a fila de deriva que ninguém vai resolver.
+        if (memoria.status !== "ativa")
+            continue;
+        for (const ancora of memoria.ancoras) {
+            const sha = await mede(raiz, ancora.valor);
+            medicoes.push({
+                pasta: memoria.pasta,
+                memoria: memoria.slug,
+                valor: ancora.valor,
+                sha,
+                ...(sha === null ? { detalhe: "alvo não encontrado na árvore de trabalho" } : {}),
+            });
+        }
+    }
+    return medicoes;
+}
+async function buscaOBrain(raiz) {
+    const config = await leConfigDoRepo(raiz);
+    const token = await leToken(config.api);
+    if (!token) {
+        throw new Error(`sem credencial para ${config.api}. Rode \`dd-harness login --token <token>\`.`);
+    }
+    const parametros = `tenant=${encodeURIComponent(config.tenant)}&projeto=${encodeURIComponent(config.projeto)}`;
+    const resposta = await pede(`${config.api}/api/v1/artefatos?${parametros}`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (resposta.status === 401) {
+        throw new Error("token recusado. Rode `dd-harness login --token <token>`.");
+    }
+    if (!resposta.ok) {
+        throw new Error(`a API respondeu ${resposta.status} ao buscar as âncoras.`);
+    }
+    return { config, token, brain: (await resposta.json()) };
+}
+/**
+ * Somente leitura, de proposito: e o que roda na ABERTURA da sessao. Medir e reportar
+ * ali dentro faria toda sessao escrever no servico antes de a pessoa digitar qualquer
+ * coisa — caro, e o tipo de efeito colateral que ninguem espera de "abrir o editor".
+ */
+export async function status(raiz) {
+    const { brain } = await buscaOBrain(raiz);
+    const agora = Date.now();
+    const ativas = brain.memorias.filter((m) => m.status === "ativa");
+    const porPasta = new Map();
+    for (const m of ativas)
+        porPasta.set(m.pasta, (porPasta.get(m.pasta) ?? 0) + 1);
+    return {
+        acervo: {
+            ativas: ativas.length,
+            arquivadas: brain.memorias.length - ativas.length,
+            porPasta: [...porPasta]
+                .map(([pasta, quantas]) => ({ pasta, quantas }))
+                .sort((a, b) => a.pasta.localeCompare(b.pasta)),
+        },
+        comDeriva: ativas
+            .filter((m) => (m.deriva_aberta ?? 0) > 0)
+            .map((m) => ({
+            pasta: m.pasta,
+            memoria: m.slug,
+            titulo: m.titulo,
+            abertas: m.deriva_aberta ?? 0,
+        })),
+        vencidas: ativas
+            .filter((m) => m.revisar_ate && new Date(m.revisar_ate).getTime() < agora)
+            .map((m) => ({ pasta: m.pasta, memoria: m.slug, titulo: m.titulo })),
+    };
+}
+export async function check(raiz, commit) {
+    const { config, token, brain } = await buscaOBrain(raiz);
+    const cabecalhos = { Authorization: `Bearer ${token}` };
+    const medicoes = await medeAsAncoras(raiz, brain);
+    // O cruzamento com o diff so faz sentido quando ha um commit para olhar.
+    const tocadas = commit
+        ? memoriasTocadas(brain, await caminhosDoCommit(raiz, commit))
+        : [];
+    if (medicoes.length === 0) {
+        return { medidas: 0, ausentes: [], novas: 0, base: 0, jaAbertas: 0, fechadas: 0, tocadas };
+    }
+    const envio = await pede(`${config.api}/api/v1/deriva`, {
+        method: "POST",
+        headers: { ...cabecalhos, "Content-Type": "application/json" },
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            commit: commit ?? null,
+            medicoes,
+        }),
+    });
+    if (envio.status === 403) {
+        throw new Error("este token não pode reportar deriva. Crie outro na interface e refaça o login.");
+    }
+    if (!envio.ok) {
+        throw new Error(`a API respondeu ${envio.status} ao registrar as medições.`);
+    }
+    const julgamento = (await envio.json());
+    return {
+        medidas: medicoes.length,
+        ausentes: medicoes.filter((m) => m.sha === null).map((m) => m.valor).sort(),
+        novas: julgamento.novas,
+        base: julgamento.base,
+        jaAbertas: julgamento.ja_abertas,
+        fechadas: julgamento.fechadas ?? 0,
+        tocadas,
+    };
+}

package/dist/cli/src/config.js

@@ -0,0 +1,81 @@
+import { createHash } from "node:crypto";
+import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * O servico publicado e o padrao: um repositorio que so declara `tenant` e `projeto` ja
+ * fala com quem existe. Para desenvolver contra a maquina local, ponha `api` explicito no
+ * `.dd-harness.json` — apontar para `localhost` por omissao deixaria todo repo novo
+ * falando com um servidor que ninguem esta rodando.
+ */
+const PADRAO = { api: "https://dd-harness.vercel.app", pasta: "dd-harness" };
+export const CAMINHO_CONFIG = ".dd-harness.json";
+export const CAMINHO_MANIFESTO = "dd-harness/manifest.json";
+export async function leConfigDoRepo(raiz) {
+    let cru;
+    try {
+        cru = await readFile(join(raiz, CAMINHO_CONFIG), "utf8");
+    }
+    catch {
+        throw new Error(`não encontrei ${CAMINHO_CONFIG} em ${raiz}. Crie com: {"tenant":"...","projeto":"..."}`);
+    }
+    const lido = JSON.parse(cru);
+    if (!lido.tenant || !lido.projeto) {
+        throw new Error(`${CAMINHO_CONFIG} precisa de "tenant" e "projeto".`);
+    }
+    return {
+        api: (lido.api ?? PADRAO.api).replace(/\/$/, ""),
+        tenant: lido.tenant,
+        projeto: lido.projeto,
+        pasta: lido.pasta ?? PADRAO.pasta,
+    };
+}
+const arquivoDeCredenciais = () => join(homedir(), ".dd-harness", "credentials.json");
+/**
+ * Credencial por origem da API: a mesma maquina pode falar com uma instalacao local e
+ * com a de producao, e misturar token entre as duas daria 401 confuso.
+ */
+export async function leToken(api) {
+    try {
+        const cru = await readFile(arquivoDeCredenciais(), "utf8");
+        const mapa = JSON.parse(cru);
+        return mapa[api] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function guardaToken(api, token) {
+    const caminho = arquivoDeCredenciais();
+    await mkdir(join(homedir(), ".dd-harness"), { recursive: true });
+    let mapa = {};
+    try {
+        mapa = JSON.parse(await readFile(caminho, "utf8"));
+    }
+    catch {
+        // Primeiro token desta maquina.
+    }
+    mapa[api] = token;
+    await writeFile(caminho, `${JSON.stringify(mapa, null, 2)}\n`, "utf8");
+    // 0600 depois de escrever. No Windows o chmod e no-op — o arquivo herda a ACL do
+    // perfil do usuario, que ja e privada; em POSIX sem isto o token nasce legivel por
+    // qualquer processo do sistema.
+    await chmod(caminho, 0o600).catch(() => { });
+    return caminho;
+}
+export const manifestoVazio = () => ({ etag: null, arquivos: {} });
+export async function leManifesto(raiz) {
+    try {
+        const cru = await readFile(join(raiz, CAMINHO_MANIFESTO), "utf8");
+        const lido = JSON.parse(cru);
+        return { etag: lido.etag ?? null, arquivos: lido.arquivos ?? {} };
+    }
+    catch {
+        return manifestoVazio();
+    }
+}
+export async function gravaManifesto(raiz, manifesto) {
+    await mkdir(join(raiz, "dd-harness"), { recursive: true });
+    await writeFile(join(raiz, CAMINHO_MANIFESTO), `${JSON.stringify(manifesto, null, 2)}\n`, "utf8");
+}
+export const hashDe = (conteudo) => createHash("sha256").update(conteudo, "utf8").digest("hex");

package/dist/cli/src/curar.js

@@ -0,0 +1,77 @@
+import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+import { gravaManifesto, hashDe, leManifesto } from "./config.js";
+import { interpreta } from "./gravar.js";
+/**
+ * Curadoria pelo agente: editar e arquivar.
+ *
+ * `gravar` sabia criar e mais nada. Uma memoria errada ficava errada, porque corrigir
+ * exigia abrir a interface — e o `CLAUDE.md` trata curadoria como obrigacao ("se
+ * encontrar uma memoria obsoleta ou errada, corrija").
+ *
+ * Editar reaproveita o mesmo markdown de `gravar`, de proposito: o agente edita o arquivo
+ * que o `sync` materializou e manda de volta. Um formato so para as duas operacoes, e o
+ * que ele ja sabe ler.
+ */
+/**
+ * Depois que o servico aceita, o arquivo em disco deixa de ser "edicao nao enviada" — e o
+ * manifesto tem que saber, senao o `sync` seguinte para com "editado a mao" e a unica saida
+ * que resta e descartar o arquivo. O ciclo materializa-corrige-envia travava justamente
+ * aqui, com o servico ja atualizado.
+ *
+ * Guarda o hash do que foi enviado, nao do que o servico devolveria: o `sync` seguinte
+ * reescreve o arquivo na forma canonica quando o ETag mudar.
+ */
+async function marcaComoEnviado(raiz, caminho, conteudo) {
+    const chave = relative(raiz, caminho).split("\\").join("/");
+    const manifesto = await leManifesto(raiz);
+    // Arquivo de fora do repositorio (um rascunho em /tmp, por exemplo) nao esta no
+    // manifesto e nao deve entrar: o manifesto descreve o que o `sync` materializou.
+    if (!manifesto.arquivos[chave])
+        return;
+    manifesto.arquivos[chave] = hashDe(conteudo);
+    await gravaManifesto(raiz, manifesto);
+}
+export async function edita(raiz, caminho) {
+    const { config, token } = await credencial(raiz);
+    const cru = await readFile(caminho, "utf8");
+    const memoria = interpreta(cru);
+    const endereco = `${memoria.pasta}/${memoria.slug}`;
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}`, {
+        method: "PATCH",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            titulo: memoria.titulo,
+            resumo: memoria.resumo,
+            corpo: memoria.corpo,
+            dano: memoria.dano,
+            invisibilidade: memoria.invisibilidade,
+            externalidade: memoria.externalidade,
+            ancoras: memoria.ancoras,
+        }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    await marcaComoEnviado(raiz, caminho, cru);
+    return { endereco, ancoras: memoria.ancoras.length };
+}
+export async function arquiva(raiz, endereco, opcoes) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}`, {
+        method: "DELETE",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            motivo: opcoes.motivo,
+            ...(opcoes.substituidaPor ? { substituida_por: opcoes.substituidaPor } : {}),
+        }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const lido = (await resposta.json());
+    return lido;
+}

package/dist/cli/src/diff.js

@@ -0,0 +1,52 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const roda = promisify(execFile);
+/**
+ * Quais memorias falam do que este commit mudou.
+ *
+ * E a peca que devolve a memoria ao code review. Tirar o Brain do repositorio tirou o
+ * revisor que o diff dava de graca — no modelo file-based a memoria estava ali, no
+ * caminho de quem mexia. Aqui ela volta pelo cruzamento: caminho do diff contra ancora.
+ *
+ * Repare que isto NAO e deriva. Deriva e "o alvo mudou desde a linha de base"; isto e
+ * "voce acabou de mexer no que esta memoria guarda" — util mesmo quando a base ainda
+ * nem foi medida, e util mesmo que a memoria continue valendo.
+ */
+/** Caminhos alterados num commit. Vazio quando o git nao responde — nunca quebra. */
+export async function caminhosDoCommit(raiz, commit) {
+    try {
+        const { stdout } = await roda("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commit], { cwd: raiz });
+        return stdout
+            .split(/\r?\n/)
+            .map((l) => l.trim())
+            .filter(Boolean);
+    }
+    catch {
+        // Sem git, commit inexistente, repositorio raso: o cruzamento simplesmente nao
+        // acontece. Um aviso que nao pode ser dado nao vira erro que atrapalha o commit.
+        return [];
+    }
+}
+/**
+ * Cruza caminhos com ancoras. A ancora casa quando e o proprio caminho ou quando e um
+ * diretorio que o contem — `supabase/migrations` tem que casar com a migration nova.
+ */
+export function memoriasTocadas(brain, caminhos) {
+    const tocadas = [];
+    for (const memoria of brain.memorias) {
+        if (memoria.status !== "ativa")
+            continue;
+        for (const ancora of memoria.ancoras) {
+            const casa = caminhos.some((c) => c === ancora.valor || c.startsWith(`${ancora.valor}/`));
+            if (casa) {
+                tocadas.push({
+                    pasta: memoria.pasta,
+                    memoria: memoria.slug,
+                    titulo: memoria.titulo,
+                    ancora: ancora.valor,
+                });
+            }
+        }
+    }
+    return tocadas;
+}

package/dist/cli/src/gravar.js

@@ -0,0 +1,105 @@
+import { readFile } from "node:fs/promises";
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+const OBRIGATORIOS = ["name", "titulo", "description", "pasta"];
+/** Frontmatter simples: `chave: valor` por linha. Sem lib de YAML — nao ha aninhamento. */
+function leFrontmatter(texto) {
+    const linhas = texto.replace(/\r\n/g, "\n").split("\n");
+    if (linhas[0]?.trim() !== "---") {
+        throw new Error("o arquivo precisa começar com `---` e um frontmatter.");
+    }
+    const fim = linhas.indexOf("---", 1);
+    if (fim === -1)
+        throw new Error("frontmatter sem `---` de fechamento.");
+    const campos = new Map();
+    for (const linha of linhas.slice(1, fim)) {
+        const corte = linha.indexOf(":");
+        if (corte === -1)
+            continue;
+        campos.set(linha.slice(0, corte).trim(), linha.slice(corte + 1).trim());
+    }
+    return { campos, resto: linhas.slice(fim + 1).join("\n") };
+}
+/** `**Dano:** texto` — devolve o texto, sem o rotulo. */
+function filtro(corpo, rotulo) {
+    const achado = corpo.match(new RegExp(`\\*\\*${rotulo}:\\*\\*\\s*([\\s\\S]*?)(?=\\n\\s*\\n\\*\\*|\\n## |$)`, "i"));
+    const valor = achado?.[1]?.trim() ?? "";
+    if (!valor)
+        throw new Error(`falta o filtro **${rotulo}:** no arquivo.`);
+    return valor;
+}
+/** Itens de lista da secao de ancoras, com ou sem crase em volta. */
+function ancorasDe(texto) {
+    const secao = texto.split(/\n##\s+[ÂA]ncoras\s*\n/i)[1];
+    if (!secao)
+        return [];
+    return secao
+        .split("\n")
+        .map((l) => l.match(/^\s*[-*]\s+(.+?)\s*$/)?.[1])
+        .filter((v) => Boolean(v))
+        .map((v) => v.replace(/^`|`$/g, "").trim())
+        .filter(Boolean);
+}
+export function interpreta(texto) {
+    const { campos, resto } = leFrontmatter(texto);
+    for (const chave of OBRIGATORIOS) {
+        if (!campos.get(chave))
+            throw new Error(`frontmatter sem \`${chave}\`.`);
+    }
+    // O corpo vai ate a secao dos filtros; dali para baixo e metadado, nao conteudo.
+    const corte = resto.search(/\n##\s+Os tr[êe]s filtros\s*\n/i);
+    if (corte === -1)
+        throw new Error("falta a seção `## Os três filtros`.");
+    const corpo = resto
+        .slice(0, corte)
+        .replace(/<!--[\s\S]*?-->/g, "")
+        .trim();
+    if (!corpo)
+        throw new Error("o corpo da memória está vazio.");
+    const cauda = resto.slice(corte);
+    const tambem = campos.get("projetos") ?? "";
+    return {
+        slug: campos.get("name"),
+        titulo: campos.get("titulo"),
+        resumo: campos.get("description"),
+        pasta: campos.get("pasta"),
+        corpo,
+        dano: filtro(cauda, "Dano"),
+        invisibilidade: filtro(cauda, "Invisibilidade"),
+        externalidade: filtro(cauda, "Externalidade"),
+        ancoras: ancorasDe(cauda),
+        tambemEm: tambem
+            .split(",")
+            .map((s) => s.trim())
+            .filter(Boolean),
+    };
+}
+export async function grava(raiz, caminho) {
+    const { config, token } = await credencial(raiz);
+    const memoria = interpreta(await readFile(caminho, "utf8"));
+    const resposta = await pede(`${config.api}/api/v1/memorias`, {
+        method: "POST",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            pasta: memoria.pasta,
+            slug: memoria.slug,
+            titulo: memoria.titulo,
+            resumo: memoria.resumo,
+            corpo: memoria.corpo,
+            dano: memoria.dano,
+            invisibilidade: memoria.invisibilidade,
+            externalidade: memoria.externalidade,
+            ancoras: memoria.ancoras,
+            tambem_em: memoria.tambemEm,
+        }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const { endereco } = (await resposta.json());
+    return {
+        endereco,
+        ancoras: memoria.ancoras.length,
+        projetos: 1 + memoria.tambemEm.length,
+    };
+}