dd-harness-mcp 0.1.0

package/dist/cli/src/pasta.js

@@ -0,0 +1,30 @@
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+/**
+ * `dd-harness pasta <slug> --definicao "..."` — cria a pasta sem sair da sessao.
+ *
+ * `gravar` recusa quando a pasta nao existe, e essa recusa e boa: e ela que impede um
+ * typo no `pasta:` de virar pasta nova em silencio. O que faltava era a saida — ate aqui
+ * o agente parava e pedia que alguem abrisse o navegador.
+ */
+export async function criaPasta(raiz, slug, definicao) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/pastas`, {
+        method: "POST",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            slug,
+            definicao,
+        }),
+    });
+    // Pasta que ja existe nao e falha para quem chamou: o estado desejado ja vale. Vale
+    // dizer que ja existia — quem pediu pode estar corrigindo um typo e precisa saber que
+    // nao criou nada.
+    if (resposta.status === 409)
+        return { pasta: slug, jaExistia: true };
+    if (!resposta.ok)
+        await recusa(resposta);
+    const { pasta } = (await resposta.json());
+    return { pasta, jaExistia: false };
+}

package/dist/cli/src/projeto.js

@@ -0,0 +1,39 @@
+import { cabecalhos, pede, recusa } from "./api.js";
+import { leConfigDoRepo, leToken } from "./config.js";
+/**
+ * `dd-harness projeto <slug> --nome "..."` — cria o projeto sem sair da sessao.
+ *
+ * Era o ultimo passo do espaco que exigia navegador. O tenant continua manual de
+ * proposito (fronteira de isolamento e ato de dono), mas daqui para baixo o agente que
+ * abre um repositorio novo consegue preparar tudo: projeto, pasta e memoria.
+ *
+ * Nao escreve o `.dd-harness.json`: quem faz isso e o `init`, e ele precisa de um projeto
+ * que ja exista. A ordem e `projeto` e depois `init` — e por isso este comando NAO pode
+ * exigir o config do repo, que nesse momento ainda nao existe. Daí `--tenant` e `--api`:
+ * sem config, eles vem da linha de comando; com config, ele preenche o que faltar.
+ */
+export async function criaProjeto(raiz, slug, nome, explicito = {}) {
+    const doRepo = await leConfigDoRepo(raiz).catch(() => null);
+    const tenant = explicito.tenant ?? doRepo?.tenant;
+    const api = (explicito.api ?? doRepo?.api ?? "https://dd-harness.vercel.app").replace(/\/$/, "");
+    if (!tenant) {
+        throw new Error("não sei em que espaço criar: passe `--tenant <slug>` (ou rode dentro de um repositório já com .dd-harness.json).");
+    }
+    const token = await leToken(api);
+    if (!token) {
+        throw new Error(`sem credencial para ${api}. Rode \`dd-harness login --token <token>\`.`);
+    }
+    const resposta = await pede(`${api}/api/v1/projetos`, {
+        method: "POST",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({ tenant, slug, nome }),
+    });
+    // Como em `pasta`: projeto que ja existe nao e falha para quem chamou, o estado desejado
+    // ja vale. Vale dizer que existia — quem pediu pode estar corrigindo um typo.
+    if (resposta.status === 409)
+        return { projeto: slug, jaExistia: true };
+    if (!resposta.ok)
+        await recusa(resposta);
+    const { projeto } = (await resposta.json());
+    return { projeto, jaExistia: false };
+}

package/dist/cli/src/sync.js

@@ -0,0 +1,153 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { pede } from "./api.js";
+import { dirname, join } from "node:path";
+import { gravaManifesto, hashDe, leConfigDoRepo, leManifesto, leToken, } from "./config.js";
+import { LINHA_DE_IMPORT, materializa } from "./materializa.js";
+async function leSeExistir(caminho) {
+    try {
+        return await readFile(caminho, "utf8");
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Estado do que este comando escreveu, contra o hash guardado.
+ *
+ * Duas situacoes diferentes, e confundi-las custa caro: hash diferente e **edicao a
+ * mao**, e o comando tem que parar sem escrever; arquivo **ausente** nao e edicao — e
+ * trabalho a refazer, e o comando tem que reescrever.
+ */
+export async function confereDisco(raiz, arquivos) {
+    const editados = [];
+    const faltando = [];
+    for (const [relativo, hashGuardado] of Object.entries(arquivos)) {
+        const atual = await leSeExistir(join(raiz, relativo));
+        if (atual === null)
+            faltando.push(relativo);
+        else if (hashDe(atual) !== hashGuardado)
+            editados.push(relativo);
+    }
+    return { editados: editados.sort(), faltando: faltando.sort() };
+}
+async function buscaBrain(config, token, etag) {
+    const url = `${config.api}/api/v1/artefatos?tenant=${encodeURIComponent(config.tenant)}&projeto=${encodeURIComponent(config.projeto)}`;
+    const resposta = await pede(url, {
+        headers: {
+            Authorization: `Bearer ${token}`,
+            ...(etag ? { "If-None-Match": etag } : {}),
+        },
+    });
+    if (resposta.status === 304)
+        return { naoMudou: true };
+    if (resposta.status === 401) {
+        throw new Error("token recusado. Rode `dd-harness login --token <token>`.");
+    }
+    if (resposta.status === 404) {
+        throw new Error(`projeto ${config.tenant}/${config.projeto} não encontrado — ou não é seu.`);
+    }
+    if (!resposta.ok) {
+        throw new Error(`a API respondeu ${resposta.status}.`);
+    }
+    return {
+        naoMudou: false,
+        brain: (await resposta.json()),
+        etag: resposta.headers.get("etag"),
+    };
+}
+/**
+ * O `CLAUDE.md` da raiz existe e importa a politica?
+ *
+ * Sem politica no servico E sem a linha, nao ha o que apontar nem o que avisar — avisar
+ * ai seria ruido que ensina a ignorar aviso. Mas com a linha escrita e a politica vazia o
+ * import esta pendurado de verdade, e esse e o silencio que a memoria
+ * `import-do-claude-md-falha-calado` manda quebrar.
+ */
+export async function confereOPonteiro(raiz, temPolitica) {
+    const claudeMd = await leSeExistir(join(raiz, "CLAUDE.md"));
+    const temALinha = claudeMd?.includes(LINHA_DE_IMPORT) ?? false;
+    if (!temPolitica)
+        return temALinha ? "aponta-para-o-vazio" : "sem-politica";
+    if (claudeMd === null)
+        return "sem-claude-md";
+    return temALinha ? "ok" : "sem-a-linha";
+}
+export async function sync(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 manifesto = await leManifesto(raiz);
+    // A guarda vem ANTES da rede, e nao depois do 304, porque a divergencia pode estar
+    // deste lado: servico igual e disco editado a mao e o caso que mais interessa avisar,
+    // e um 304 que respondesse "nada mudou" o esconderia.
+    const { editados, faltando } = await confereDisco(raiz, manifesto.arquivos);
+    const politicaNoManifesto = Object.keys(manifesto.arquivos).some((a) => a.endsWith(`${config.pasta}/politica.md`));
+    if (editados.length) {
+        return {
+            tipo: "editado-a-mao",
+            arquivos: editados,
+            ponteiro: await confereOPonteiro(raiz, politicaNoManifesto),
+        };
+    }
+    // `If-None-Match` so quando o disco esta completo. Faltando arquivo, um 304 diria
+    // "nada a fazer" e o comando nunca conseguiria reescrever o que foi apagado — a
+    // sincronizacao ficaria incapaz de consertar o disco, que e metade do trabalho dela.
+    const resposta = await buscaBrain(config, token, faltando.length ? null : manifesto.etag);
+    if (resposta.naoMudou) {
+        // Confere mesmo sem mudanca no servico: quem apaga a linha de import e quem mexe no
+        // repositorio, e um 304 nao sabe nada sobre isso.
+        return {
+            tipo: "sem-mudanca",
+            ponteiro: await confereOPonteiro(raiz, politicaNoManifesto),
+        };
+    }
+    const desejado = materializa(resposta.brain, config.pasta);
+    // Arquivo que o servico quer escrever e que existe em disco sem estar no manifesto e
+    // de outra origem — escrito a mao antes do primeiro sync. Tambem nao e nosso.
+    const alheios = [];
+    for (const relativo of desejado.keys()) {
+        if (manifesto.arquivos[relativo])
+            continue;
+        if ((await leSeExistir(join(raiz, relativo))) !== null)
+            alheios.push(relativo);
+    }
+    if (alheios.length) {
+        return {
+            tipo: "editado-a-mao",
+            arquivos: alheios.sort(),
+            ponteiro: await confereOPonteiro(raiz, desejado.has(`${config.pasta}/politica.md`)),
+        };
+    }
+    const escritos = [];
+    for (const [relativo, conteudo] of desejado) {
+        const caminho = join(raiz, relativo);
+        const atual = await leSeExistir(caminho);
+        if (atual === conteudo)
+            continue;
+        await mkdir(dirname(caminho), { recursive: true });
+        await writeFile(caminho, conteudo, "utf8");
+        escritos.push(relativo);
+    }
+    // Memoria que saiu do servico tem que sair do disco, senao o repo guarda para sempre
+    // uma memoria que ninguem mais vai atualizar. So remove o que era nosso e nao mudou.
+    const removidos = [];
+    for (const relativo of Object.keys(manifesto.arquivos)) {
+        if (desejado.has(relativo))
+            continue;
+        await rm(join(raiz, relativo), { force: true });
+        removidos.push(relativo);
+    }
+    const novo = {
+        etag: resposta.etag,
+        arquivos: Object.fromEntries([...desejado].map(([relativo, conteudo]) => [relativo, hashDe(conteudo)])),
+    };
+    await gravaManifesto(raiz, novo);
+    return {
+        tipo: "sincronizado",
+        escritos: escritos.sort(),
+        removidos: removidos.sort(),
+        ponteiro: await confereOPonteiro(raiz, desejado.has(`${config.pasta}/politica.md`)),
+    };
+}

package/dist/mcp/src/index.js

@@ -0,0 +1,265 @@
+import { McpServer } from "@modelcontextprotocol/server";
+import { serveStdio } from "@modelcontextprotocol/server/stdio";
+import * as z from "zod/v4";
+// Caminho relativo ao fonte do CLI, nao `dd-harness/*`: aquele campo aponta para `dist`,
+// 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 } 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";
+import { escreveArtefato, leArtefato } from "../../cli/src/artefato.js";
+import { grava } from "../../cli/src/gravar.js";
+/**
+ * O mesmo servico, outra porta.
+ *
+ * O CLI exige que o agente saiba que ele existe: alguem tem que ter escrito na politica
+ * "rode `dd-harness buscar`". Ferramenta MCP chega ao contexto por estar disponivel — o
+ * agente le a descricao sem ninguem instruir, e decide se quer.
+ *
+ * Isso muda o que a descricao precisa carregar. Os tres filtros sao CHECK no banco e prosa
+ * na skill: quem nunca leu a skill descobre a regra por 422. Aqui eles vao na descricao da
+ * ferramenta, que e onde o agente olha antes de tentar.
+ *
+ * `init`, `sync`, `login` e `check` ficam de fora de proposito: sao bootstrap e fluxo de
+ * quem esta no terminal, e materializar arquivo nao e trabalho de ferramenta de sessao.
+ */
+/** Tudo roda contra o repositorio de onde o host lancou o servidor. */
+const raiz = process.cwd();
+const texto = (t) => ({ content: [{ type: "text", text: t }] });
+const falha = (erro) => ({
+    content: [
+        { type: "text", text: erro instanceof Error ? erro.message : String(erro) },
+    ],
+    isError: true,
+});
+const FILTROS = `Os três filtros são CONJUNTIVOS: a memória só nasce se os três valerem, e o banco recusa quem não passa.
+- dano: se ninguém souber disto, alguém desfaz e QUEBRA algo? "é interessante de saber" não é dano.
+- invisibilidade: o próprio repositório já conta (um config, uma dependência, um teste, um nome bem escolhido)? Se conta, NÃO grave. "eu explico melhor que o código" não é invisibilidade.
+- externalidade: a razão vem de FORA do código — sistema legado, compliance, limite de fornecedor, número mágico, bug de terceiro? "foi uma decisão difícil" não é externalidade.
+Decisão difícil e reversível não vira memória — vira commit. Cada campo exige no mínimo 10 caracteres de justificativa real.`;
+function criaServidor() {
+    const server = new McpServer({ name: "dd-harness", version: "0.1.0" });
+    server.registerTool("buscar_memoria", {
+        description: `Procura no Brain do projeto por relevância e devolve endereço, título e resumo — não o corpo. Use quando estiver entendendo um problema e ainda não souber que arquivo abrir ("o que já aprendemos sobre isto?").
+
+Para ler o corpo de um achado, abra o arquivo que o \`dd-harness sync\` materializou em \`dd-harness/brain/<endereço>.md\`.
+
+A busca combina semântica e lexical e tem piso de similaridade: quando nada é pertinente ela devolve lista vazia em vez de inventar o vizinho mais próximo. Lista vazia é resposta, não falha.
+
+Os primeiros achados são os que valem: o piso barra tema alheio, mas num Brain temático a relevância decai de forma contínua, sem corte óbvio. Leia de cima para baixo e pare quando deixar de fazer sentido.`,
+        inputSchema: z.object({
+            consulta: z
+                .string()
+                .min(1)
+                .describe("A pergunta em texto livre, como você a formularia para um colega."),
+            limite: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .describe("Quantos achados no máximo (padrão 4). Suba só quando os primeiros não bastarem: num acervo temático o resultado 10 ainda fala do projeto, mas já não responde à pergunta."),
+        }),
+    }, async ({ consulta, limite }) => {
+        try {
+            // Menos que o padrao da rota (10), medido: num acervo tematico a similaridade decai
+            // continuamente, sem vale entre pertinente e "do mesmo projeto" — com 15 memorias o
+            // 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);
+            if (r.achados.length === 0) {
+                return texto(`Nada pertinente no Brain para "${consulta}".` +
+                    (r.semantica ? "" : " (Busca lexical apenas: sem provedor de embedding configurado.)"));
+            }
+            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")}`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("gravar_memoria", {
+        description: `Registra uma memória nova no Brain do projeto. O default é NÃO gravar: proponha ao humano antes, e grave o que ele aprovar.
+
+${FILTROS}
+
+A pasta precisa existir antes — use \`criar_pasta\`. Essa recusa é deliberada: ela impede um typo virar pasta nova em silêncio.
+
+Âncoras (opcional) amarram a memória ao código, e são o que faz a memória ser recuperada quando alguém mexe naquele ponto. Caminho relativo à raiz, sem \`..\` e sem separador do Windows. Duas formas:
+
+- \`src/api/encurtar.js\` — o arquivo inteiro. Use quando a memória fala do arquivo como um todo.
+- \`src/api/encurtar.js#readFileSync\` — só as linhas que contêm \`readFileSync\`. PREFIRA esta: quando várias memórias dividem um arquivo, a âncora de arquivo acusa todas a cada mudança em qualquer parte dele, e o aviso perde valor. Escolha um texto estável e específico do que a memória descreve (um nome de função, uma constante, uma chave de config) — não um trecho que a próxima refatoração reescreve à toa.`,
+        inputSchema: z.object({
+            arquivo: z
+                .string()
+                .min(1)
+                .describe("Caminho de um .md no formato que o sync materializa: frontmatter com name/titulo/description/pasta, corpo, e a seção `## Os três filtros` com **Dano:**, **Invisibilidade:** e **Externalidade:**. Âncoras vão numa seção `## Âncoras` como itens de lista."),
+        }),
+    }, async ({ arquivo }) => {
+        try {
+            const r = await grava(raiz, arquivo);
+            return texto(`Gravado ${r.endereco} — ${r.ancoras} âncora(s), valendo para ${r.projetos} projeto(s).\n` +
+                "Rode `dd-harness sync` para materializar, e `pnpm worker --uma-vez` para entrar na busca semântica.");
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("editar_memoria", {
+        description: `Corrige uma memória que já existe, pelo mesmo formato markdown de \`gravar_memoria\`. O endereço sai do frontmatter (pasta + name), então edite o arquivo que o \`sync\` materializou.
+
+Os três filtros continuam valendo na edição — o banco recusa igual. ${FILTROS}`,
+        inputSchema: z.object({
+            arquivo: z
+                .string()
+                .min(1)
+                .describe("Caminho do .md da memória, normalmente `dd-harness/brain/<pasta>/<slug>.md`."),
+        }),
+    }, async ({ arquivo }) => {
+        try {
+            const r = await edita(raiz, arquivo);
+            return texto(`Editado ${r.endereco} — ${r.ancoras} âncora(s).`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("arquivar_memoria", {
+        description: `Arquiva uma memória. Nunca apaga: ela sai do Brain ativo e migra para a seção \`## Histórico\` do índice, com o motivo registrado.
+
+Use \`substituida_por\` quando outra memória toma o lugar desta — a troca acontece numa transação só, e o histórico aponta para a sucessora.`,
+        inputSchema: z.object({
+            endereco: z
+                .string()
+                .min(1)
+                .describe("`<pasta>/<slug>`, como aparece no índice do Brain."),
+            motivo: z
+                .enum(["obsoleta", "incorreta", "fora_dos_filtros"])
+                .describe("obsoleta: era verdade e deixou de ser. incorreta: nunca foi verdade. fora_dos_filtros: não passava nos três filtros e não deveria ter sido gravada."),
+            substituida_por: z
+                .string()
+                .optional()
+                .describe("`<pasta>/<slug>` da memória que assume o lugar desta, se houver."),
+        }),
+    }, async ({ endereco, motivo, substituida_por }) => {
+        try {
+            const r = await arquiva(raiz, endereco, { motivo, substituidaPor: substituida_por });
+            return texto(`Arquivado ${r.endereco} — motivo: ${r.motivo}.` +
+                (substituida_por ? ` Substituída por ${substituida_por}.` : ""));
+        }
+        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.
+
+Use quando estiver começando num repositório que ainda não tem \`.dd-harness.json\`, ANTES de \`dd-harness init\`: o init escreve a configuração apontando para um projeto, e apontar para um que não existe deixa todo comando seguinte em 404.
+
+O \`slug\` é a chave que o repositório guarda, e é único por espaço — renomear depois quebraria o ponteiro, então escolha pensando nisso. O \`nome\` é livre e editável, é o que aparece na interface.
+
+O ESPAÇO (tenant) não se cria por aqui, de propósito: ele é a fronteira de isolamento entre pessoas, e isso é decisão do dono. Se não houver espaço nenhum, pare e peça que ele crie pela interface.`,
+        inputSchema: z.object({
+            slug: z
+                .string()
+                .min(2)
+                .describe("Identificador curto em minúsculas, com hifens: `pingpong3d`."),
+            nome: z.string().min(1).describe("Como aparece na interface: `Ping-Pong 3D`."),
+            tenant: z
+                .string()
+                .optional()
+                .describe("Slug do espaço. Obrigatório quando ainda não há `.dd-harness.json` no repositório — que é o caso normal de quem está criando o projeto."),
+        }),
+    }, async ({ slug, nome, tenant }) => {
+        try {
+            const r = await criaProjeto(raiz, slug, nome, { tenant });
+            return texto(r.jaExistia
+                ? `O projeto ${r.projeto} já existia — nada foi criado.`
+                : `Projeto ${r.projeto} criado. Agora rode \`dd-harness init --tenant <espaço> --projeto ${r.projeto}\`.`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("criar_pasta", {
+        description: `Cria uma pasta temática no Brain. \`gravar_memoria\` recusa quando a pasta não existe, e esta é a saída.
+
+A pasta é deste projeto, nomeada pelo domínio dele. Antes de criar uma nova, prefira ENCAIXAR numa que já existe (leia as definições das atuais): pasta de um arquivo só fragmenta o índice e sai do radar. Pasta nova exige que a memória não caiba em nenhuma existente E que você consiga nomear outra memória futura plausível que cairia nela.
+
+Criar uma que já existe não é erro: devolve que já existia, sem alterar a definição.`,
+        inputSchema: z.object({
+            slug: z
+                .string()
+                .min(1)
+                .describe("Identificador curto em minúsculas, como `banco` ou `integracoes`."),
+            definicao: z
+                .string()
+                .min(10)
+                .describe("O que entra e o que NÃO entra nesta pasta. É o que se consulta ao decidir onde uma memória vai, então diga também o que fica de fora."),
+        }),
+    }, async ({ slug, definicao }) => {
+        try {
+            const r = await criaPasta(raiz, slug, definicao);
+            return texto(r.jaExistia
+                ? `A pasta ${r.pasta} já existia — nada foi criado nem alterado.`
+                : `Pasta ${r.pasta} criada.`);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("ler_artefato", {
+        description: `Lê a política ou o briefing do projeto direto do serviço.
+
+- \`politica\`: as regras que valem neste projeto — proibições, o protocolo antes de implementar, o que exige autorização. É o que o \`CLAUDE.md\` do repositório importa.
+- \`briefing\`: o retrato estável do projeto — stack, objetivo, restrições.
+
+Devolve vazio quando o artefato ainda não existe. Vazio não é erro: projeto novo nasce assim, e a saída é escrever o primeiro conteúdo, não investigar falha.`,
+        inputSchema: z.object({
+            tipo: z
+                .enum(["politica", "briefing"])
+                .describe("Qual dos dois artefatos ler."),
+        }),
+    }, async ({ tipo }) => {
+        try {
+            const r = await leArtefato(raiz, tipo);
+            if (!r.existe) {
+                return texto(`O ${tipo} deste projeto está vazio — ainda não foi escrito. Use \`escrever_artefato\` para criar o primeiro conteúdo.`);
+            }
+            return texto(r.conteudo);
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    server.registerTool("escrever_artefato", {
+        description: `Substitui a política ou o briefing do projeto. Proponha ao humano antes: a política é a regra que governa as próprias sessões, e trocá-la sem combinar muda o que vale para todo mundo que abrir este repositório.
+
+SUBSTITUIÇÃO TOTAL, não acréscimo. O conteúdo enviado passa a ser o artefato inteiro — para acrescentar um parágrafo, use \`ler_artefato\` primeiro, junte o que falta e mande o texto completo. Mandar só o trecho novo APAGA o resto.
+
+Conteúdo vazio é válido e significa apagar o artefato.`,
+        inputSchema: z.object({
+            tipo: z
+                .enum(["politica", "briefing"])
+                .describe("Qual dos dois artefatos escrever."),
+            conteudo: z
+                .string()
+                .describe("O markdown completo do artefato, não um trecho. Limite de 200 mil caracteres."),
+        }),
+    }, async ({ tipo, conteudo }) => {
+        try {
+            const r = await escreveArtefato(raiz, tipo, conteudo);
+            return texto(`${r.criou ? "Criado" : "Atualizado"} o ${r.artefato} — ${r.tamanho} caractere(s).` +
+                (tipo === "politica"
+                    ? " A política nova vale a partir da próxima sessão."
+                    : ""));
+        }
+        catch (erro) {
+            return falha(erro);
+        }
+    });
+    return server;
+}
+serveStdio(criaServidor);

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "dd-harness-mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Servidor MCP do dd-harness: o agente consulta e grava memoria como ferramenta, sem passar por arquivo.",
+  "license": "UNLICENSED",
+  "author": "Diego Dias",
+  "keywords": [
+    "claude-code",
+    "mcp",
+    "model-context-protocol",
+    "ai-agents",
+    "memory"
+  ],
+  "homepage": "https://dd-harness.vercel.app",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/diegodias93/dd-harness-online.git",
+    "directory": "packages/mcp"
+  },
+  "//bin": "`dist/mcp/src/` e nao `dist/` porque o build abrange dois diretorios (este pacote e o fonte do CLI), e o `rootDir` comum e `packages/`. Conferir com `node dist/mcp/src/index.js` antes de publicar: caminho errado aqui instala e quebra no primeiro uso.",
+  "bin": {
+    "dd-harness-mcp": "dist/mcp/src/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/server": "^2.0.0",
+    "dd-harness": "workspace:*",
+    "zod": "^4.5.4"
+  },
+  "scripts": {
+    "typecheck": "tsc -p . --noEmit",
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  }
+}