dd-harness-mcp 0.5.0 → 0.7.0

package/dist/cli/src/acentuacao.js

@@ -0,0 +1,251 @@
+/**
+ * Recusa conteudo em pt-BR escrito sem acento — o portao, nao um pedido.
+ *
+ * **Gemeo de `src/lib/acentuacao.ts`, de proposito.** O CLI e publicado no npm com
+ * `files: ["dist"]` e sem nenhuma dependencia; importar do app quebraria o pacote
+ * instalado, e fazer o app depender do pacote publicavel so para compartilhar uma lista
+ * de palavras acopla mais do que resolve. O `tsconfig.build.json` do MCP ja assume essa
+ * troca ("duplica algumas funcoes no pacote publicado, e esse e o preco"). Mesma escolha
+ * de `recusaAncoraInvalida`, que tambem espelha de proposito um CHECK do banco: a API e a
+ * autoridade, isto aqui so adianta o erro antes da rede. **Mudou a lista aqui, mude la.**
+ *
+ * **Por que isto existe.** Acento entra no embedding. Medido com
+ * `text-embedding-3-small` nas frases reais do acervo, a mesma sentenca com e sem acento
+ * da ~0,94 de similaridade: 6% de perda. Sozinho nao seria fatal; o que quebra a busca e
+ * a **assimetria** — com metade do acervo acentuado e metade nao, o vizinho mais proximo
+ * passa a ser quem casa com a GRAFIA da consulta, nao quem e mais relevante. A busca nao
+ * devolve erro: devolve resultado ruim com aparencia de bom, que e a falha que este
+ * projeto mais combate (mesma razao de `provedor.ts` recusar vetor de outro provedor).
+ *
+ * **Por que recusar em vez de corrigir.** Restaurar acento por heuristica erra: `e`/`é`,
+ * `esta`/`está`, `secretaria`/`secretária` dependem de sintaxe, nao de ortografia. Corrigir
+ * gravaria conteudo adulterado em silencio — pior que recusar, porque ninguem revisa.
+ *
+ * **Por que lista de palavras e nao dicionario.** Sem dependencia nova, e o alvo e o caso
+ * real observado: o texto INTEIRO em ASCII. Codigo, termo em ingles e nome proprio nao
+ * disparam porque nao estao na lista.
+ */
+/**
+ * Palavras cuja grafia correta em pt-BR SEMPRE leva acento — nao existe homografo sem
+ * acento que as torne ambiguas.
+ *
+ * Criterio de entrada nesta lista: a forma sem acento **nao e palavra** do portugues.
+ * Por isso `e` (de `é`), `esta` (de `está`), `so` (de `só`), `ate` (de `até`) ficam de
+ * FORA por mais comuns que sejam — `e`, `esta` e `so` existem sozinhas, e acusar um texto
+ * legitimo e pior do que deixar um passar. A lista nao precisa ser exaustiva: basta pegar
+ * texto corrido em pt-BR, e um paragrafo de verdade quase sempre tem varias destas.
+ */
+const SEMPRE_ACENTUADAS = new Map([
+    ["nao", "não"],
+    ["sao", "são"],
+    ["tambem", "também"],
+    ["entao", "então"],
+    ["porem", "porém"],
+    ["alem", "além"],
+    ["memoria", "memória"],
+    ["memorias", "memórias"],
+    ["codigo", "código"],
+    ["funcao", "função"],
+    ["funcoes", "funções"],
+    ["versao", "versão"],
+    ["versoes", "versões"],
+    ["validacao", "validação"],
+    ["informacao", "informação"],
+    ["informacoes", "informações"],
+    ["aplicacao", "aplicação"],
+    ["configuracao", "configuração"],
+    ["implementacao", "implementação"],
+    ["decisao", "decisão"],
+    ["decisoes", "decisões"],
+    ["excecao", "exceção"],
+    ["excecoes", "exceções"],
+    ["padrao", "padrão"],
+    ["usuario", "usuário"],
+    ["usuarios", "usuários"],
+    ["necessario", "necessário"],
+    ["obrigatorio", "obrigatório"],
+    ["proprio", "próprio"],
+    ["propria", "própria"],
+    ["publico", "público"],
+    ["publica", "pública"],
+    ["unico", "único"],
+    ["unica", "única"],
+    ["basico", "básico"],
+    ["automatico", "automático"],
+    ["historico", "histórico"],
+    ["numero", "número"],
+    ["numeros", "números"],
+    ["calculo", "cálculo"],
+    ["metodo", "método"],
+    ["modulo", "módulo"],
+    ["servico", "serviço"],
+    ["servicos", "serviços"],
+    ["referencia", "referência"],
+    ["consequencia", "consequência"],
+    ["dependencia", "dependência"],
+    ["experiencia", "experiência"],
+    ["sequencia", "sequência"],
+    ["transacao", "transação"],
+    ["sessao", "sessão"],
+    ["expiracao", "expiração"],
+    ["precisao", "precisão"],
+    ["preco", "preço"],
+    ["precos", "preços"],
+    ["cabecalho", "cabeçalho"],
+    ["comeca", "começa"],
+    ["comecar", "começar"],
+    ["criterio", "critério"],
+    ["criterios", "critérios"],
+    ["dominio", "domínio"],
+    ["indice", "índice"],
+    ["minimo", "mínimo"],
+    ["maximo", "máximo"],
+    ["ultimo", "último"],
+    ["proximo", "próximo"],
+    ["disponivel", "disponível"],
+    ["possivel", "possível"],
+    ["impossivel", "impossível"],
+    ["responsavel", "responsável"],
+    ["nivel", "nível"],
+    ["util", "útil"],
+    ["dificil", "difícil"],
+    ["facil", "fácil"],
+    ["ja", "já"],
+    ["voce", "você"],
+    ["ambiguo", "ambíguo"],
+    ["generico", "genérico"],
+    ["especifico", "específico"],
+    ["logica", "lógica"],
+    ["pagina", "página"],
+    ["paginas", "páginas"],
+    ["orfao", "órfão"],
+    ["apos", "após"],
+    ["atraves", "através"],
+    ["representacao", "representação"],
+    ["representacoes", "representações"],
+    ["operacao", "operação"],
+    ["operacoes", "operações"],
+    ["integracao", "integração"],
+    ["migracao", "migração"],
+    ["autenticacao", "autenticação"],
+    ["autorizacao", "autorização"],
+    ["indexacao", "indexação"],
+    ["condicao", "condição"],
+    ["condicoes", "condições"],
+    ["relacao", "relação"],
+    ["situacao", "situação"],
+    ["definicao", "definição"],
+    ["descricao", "descrição"],
+    ["restricao", "restrição"],
+    ["restricoes", "restrições"],
+    ["execucao", "execução"],
+    ["atencao", "atenção"],
+    ["intencao", "intenção"],
+    ["manutencao", "manutenção"],
+    ["observacao", "observação"],
+    ["alteracao", "alteração"],
+    ["criacao", "criação"],
+    ["remocao", "remoção"],
+    ["gravacao", "gravação"],
+    ["duplicacao", "duplicação"],
+    ["comparacao", "comparação"],
+    ["verificacao", "verificação"],
+    ["conteudo", "conteúdo"],
+    ["politica", "política"],
+    ["politicas", "políticas"],
+    ["estrategia", "estratégia"],
+    ["tecnico", "técnico"],
+    ["tecnica", "técnica"],
+    ["semantica", "semântica"],
+    ["semantico", "semântico"],
+    ["parametro", "parâmetro"],
+    ["parametros", "parâmetros"],
+    ["variavel", "variável"],
+    ["variaveis", "variáveis"],
+    ["multiplo", "múltiplo"],
+    ["multiplos", "múltiplos"],
+    ["multipla", "múltipla"],
+    ["invalido", "inválido"],
+    ["invalida", "inválida"],
+    ["valido", "válido"],
+    ["obrigatoria", "obrigatória"],
+    ["tres", "três"],
+    ["proposito", "propósito"],
+    ["cenario", "cenário"],
+    ["relatorio", "relatório"],
+    ["diretorio", "diretório"],
+    ["repositorio", "repositório"],
+    ["formulario", "formulário"],
+    ["comentario", "comentário"],
+    ["comentarios", "comentários"],
+    ["glossario", "glossário"],
+    ["saidas", "saídas"],
+    ["duvida", "dúvida"],
+    ["duvidas", "dúvidas"],
+    ["ausencia", "ausência"],
+    ["presenca", "presença"],
+    ["diferenca", "diferença"],
+    ["diferencas", "diferenças"],
+    ["seguranca", "segurança"],
+    ["licenca", "licença"],
+    ["mudanca", "mudança"],
+    ["mudancas", "mudanças"],
+    ["heranca", "herança"],
+    ["cabecalhos", "cabeçalhos"],
+    ["comecam", "começam"],
+    ["sera", "será"],
+    ["serao", "serão"],
+]);
+/**
+ * Devolve as palavras que exigem acento e apareceram sem ele.
+ *
+ * Percorre o texto ja em minusculas e sem os trechos onde ASCII e legitimo: bloco de
+ * codigo (``` ... ```), codigo inline (`...`), URL e caminho de arquivo. Sem isso, um
+ * `preco_centavos` no meio de um identificador acusaria prosa que esta correta.
+ */
+export function palavrasSemAcento(texto) {
+    const limpo = texto
+        .replace(/```[\s\S]*?```/g, " ")
+        .replace(/`[^`\n]*`/g, " ")
+        .replace(/\bhttps?:\/\/\S+/gi, " ")
+        .replace(/\b[\w./-]+\.(?:ts|tsx|js|mjs|json|md|sql|css|html|py|sh)\b/gi, " ")
+        .toLowerCase();
+    const achadas = new Map();
+    for (const bruta of limpo.split(/[^a-zà-ÿ]+/)) {
+        if (!bruta)
+            continue;
+        const correto = SEMPRE_ACENTUADAS.get(bruta);
+        if (correto)
+            achadas.set(bruta, correto);
+    }
+    return [...achadas].map(([escrito, correto]) => ({ escrito, correto }));
+}
+/**
+ * A mensagem de recusa, ou `null` se o texto passa.
+ *
+ * Recebe os campos ja separados para poder dizer ONDE esta o problema — quem escreveu o
+ * corpo inteiro sem acento nao quer procurar a palavra em 40 linhas.
+ */
+export function recusaPorAcentuacao(campos) {
+    const porCampo = campos
+        .map(({ campo, texto }) => ({ campo, suspeitas: palavrasSemAcento(texto) }))
+        .filter((c) => c.suspeitas.length > 0);
+    if (porCampo.length === 0)
+        return null;
+    const detalhe = porCampo
+        .map(({ campo, suspeitas }) => {
+        const amostra = suspeitas
+            .slice(0, 5)
+            .map((s) => `${s.escrito} → ${s.correto}`)
+            .join(", ");
+        const resto = suspeitas.length > 5 ? `, e mais ${suspeitas.length - 5}` : "";
+        return `  ${campo}: ${amostra}${resto}`;
+    })
+        .join("\n");
+    return ("conteúdo em pt-BR sem acentuação. A acentuação entra no embedding: a mesma frase " +
+        "sem acento cai para ~0,94 de similaridade, e um acervo com grafia misturada faz a " +
+        "busca premiar quem escreve igual à consulta em vez de quem é relevante.\n" +
+        `${detalhe}\n` +
+        "Reescreva com a acentuação correta — não é corrigido automaticamente porque " +
+        "adivinhar entre `e`/`é` e `esta`/`está` gravaria texto adulterado em silêncio.");
+}

package/dist/cli/src/config.js

@@ -31,6 +31,24 @@ export async function leConfigDoRepo(raiz) {
     };
 }
 const arquivoDeCredenciais = () => join(homedir(), ".dd-harness", "credentials.json");
+const arquivoDeConfigDaMaquina = () => join(homedir(), ".dd-harness", "config.json");
+export async function leConfigDaMaquina() {
+    try {
+        const cru = await readFile(arquivoDeConfigDaMaquina(), "utf8");
+        return JSON.parse(cru);
+    }
+    catch {
+        return {};
+    }
+}
+export async function guardaConfigDaMaquina(parcial) {
+    const caminho = arquivoDeConfigDaMaquina();
+    await mkdir(join(homedir(), ".dd-harness"), { recursive: true });
+    const atual = await leConfigDaMaquina();
+    const mesclado = { ...atual, ...parcial };
+    await writeFile(caminho, `${JSON.stringify(mesclado, null, 2)}\n`, "utf8");
+    return caminho;
+}
 /**
  * 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.

package/dist/cli/src/escreve-config.js

@@ -0,0 +1,101 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+const COMANDO_DO_HOOK = "dd-harness politica --hook";
+/**
+ * Acrescenta o hook do dd-harness a `.claude/settings.json`, sem tocar em outros hooks.
+ *
+ * `SessionStart` e um ARRAY de matcher groups no schema do Claude Code — pensado para
+ * varios hooks convivendo. Por isso a acao certa quando ja existe outro hook de
+ * SessionStart e ACRESCENTAR um grupo novo ao array, nao substituir nem perguntar: sao
+ * dois hooks independentes, cada um cuidando da sua coisa.
+ */
+export async function escreveHook(raiz) {
+    const caminho = join(raiz, ".claude", "settings.json");
+    let doc = {};
+    try {
+        const cru = await readFile(caminho, "utf8");
+        doc = JSON.parse(cru);
+    }
+    catch (erro) {
+        if (erro.code !== "ENOENT") {
+            return { ok: false, motivo: "json-invalido", caminho };
+        }
+    }
+    const hooks = (doc.hooks ??= {});
+    const sessionStart = (hooks.SessionStart ??= []);
+    const jaTemONosso = JSON.stringify(sessionStart).includes(COMANDO_DO_HOOK);
+    if (jaTemONosso)
+        return { ok: true, estado: "ja-tinha" };
+    const eraVazio = sessionStart.length === 0;
+    sessionStart.push({
+        hooks: [
+            {
+                type: "command",
+                command: COMANDO_DO_HOOK,
+                statusMessage: "Carregando a política do dd-harness...",
+            },
+        ],
+    });
+    await mkdir(dirname(caminho), { recursive: true });
+    await writeFile(caminho, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return { ok: true, estado: eraVazio ? "criado" : "acrescentado" };
+}
+/** Acrescenta o servidor MCP a `.mcp.json`, sem tocar em outros servidores. */
+export async function escreveMcp(raiz) {
+    const caminho = join(raiz, ".mcp.json");
+    let doc = {};
+    try {
+        const cru = await readFile(caminho, "utf8");
+        doc = JSON.parse(cru);
+    }
+    catch (erro) {
+        if (erro.code !== "ENOENT") {
+            return { ok: false, motivo: "json-invalido", caminho };
+        }
+    }
+    const servidores = (doc.mcpServers ??= {});
+    if (servidores["dd-harness"])
+        return { ok: true, estado: "ja-tinha" };
+    const eraVazio = Object.keys(servidores).length === 0;
+    servidores["dd-harness"] = { command: "npx", args: ["-y", "dd-harness-mcp"] };
+    await mkdir(dirname(caminho), { recursive: true });
+    await writeFile(caminho, `${JSON.stringify(doc, null, 2)}\n`, "utf8");
+    return { ok: true, estado: eraVazio ? "criado" : "acrescentado" };
+}
+/**
+ * `AGENTS.md` e markdown livre, nao JSON — nao ha "mesclar" de verdade. Se o arquivo ja
+ * existe (com qualquer conteudo), so acrescenta a instrucao no fim; nunca sobrescreve
+ * o que a pessoa escreveu, porque markdown de outra ferramenta e mais dificil de separar
+ * do nosso do que uma chave de objeto.
+ */
+export async function escreveAgents(raiz) {
+    const caminho = join(raiz, "AGENTS.md");
+    const instrucao = SUGESTAO_AGENTS;
+    let atual = null;
+    try {
+        atual = await readFile(caminho, "utf8");
+    }
+    catch {
+        // Sem arquivo: cria do zero.
+    }
+    if (atual === null) {
+        await writeFile(caminho, `${instrucao}\n`, "utf8");
+        return { estado: "criado" };
+    }
+    if (atual.includes("ler_artefato"))
+        return { estado: "ja-tinha" };
+    const separador = atual.endsWith("\n") ? "\n" : "\n\n";
+    await writeFile(caminho, `${atual}${separador}${instrucao}\n`, "utf8");
+    return { estado: "acrescentado" };
+}
+const SUGESTAO_AGENTS = `## Protocolo do dd-harness
+
+Este projeto tem um protocolo de trabalho que **não está neste arquivo**.
+
+**ANTES de qualquer outra coisa**, chame a ferramenta MCP \`ler_artefato\` com
+\`tipo: "politica"\` e siga o que ela devolver. É a primeira ação da sessão, antes
+de ler código, responder ou planejar.
+
+- Se a ferramenta não existir, o servidor MCP do dd-harness não está declarado:
+  avise o usuário e **não modifique nada** até ele resolver.
+- Se ela devolver vazio, este projeto nunca foi briefado — diga isso ao usuário.`;

package/dist/cli/src/gravar.js

@@ -1,4 +1,5 @@
 import { readFile } from "node:fs/promises";
+import { recusaPorAcentuacao } from "./acentuacao.js";
 import { cabecalhos, credencial, pede, recusa } from "./api.js";
 const OBRIGATORIOS = ["name", "titulo", "description", "pasta"];
 /**
@@ -135,6 +136,15 @@ export function interpreta(texto) {
         .trim();
     if (!corpo)
         throw new Error("o corpo da memória está vazio.");
+    // A acentuacao entra no embedding, entao grafia misturada degrada a busca de todo o
+    // acervo. A API recusa igual; aqui o erro chega antes da rede e ja aponta a palavra.
+    const semAcento = recusaPorAcentuacao([
+        { campo: "titulo", texto: campos.get("titulo") },
+        { campo: "description", texto: campos.get("description") },
+        { campo: "corpo", texto: corpo },
+    ]);
+    if (semAcento)
+        throw new Error(semAcento);
     const cauda = resto.slice(corte);
     const tambem = campos.get("projetos") ?? "";
     return {

package/dist/cli/src/index.js

@@ -1,14 +1,19 @@
 #!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { access } from "node:fs/promises";
+import { join } from "node:path";
 import { termosDaConsulta } from "./argv.js";
 import { check, status } from "./check.js";
-import { leConfigDoRepo, guardaToken } from "./config.js";
+import { CAMINHO_CONFIG, guardaConfigDaMaquina, guardaToken, leConfigDaMaquina, leConfigDoRepo, leToken, } from "./config.js";
+import { escreveAgents, escreveHook, escreveMcp } from "./escreve-config.js";
 import { grava } from "./gravar.js";
 import { init, SUGESTAO_AGENTS, SUGESTAO_HOOK, SUGESTAO_MCP } from "./init.js";
+import { pergunta, escolha, fechaPerguntas } from "./pergunta.js";
 import { buscaPolitica } from "./politica.js";
 import { busca } from "./buscar.js";
 import { arquiva, edita, le } from "./curar.js";
 import { criaPasta } from "./pasta.js";
-import { criaProjeto } from "./projeto.js";
+import { criaProjeto, listaTenants } from "./projeto.js";
 import { reancora } from "./reancorar.js";
 import { subiuOWorker } from "./worker.js";
 /**
@@ -21,6 +26,8 @@ import { subiuOWorker } from "./worker.js";
  */
 const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
 
+  dd-harness start                  numa pasta vazia: conduz tudo (login,
+                                     espaço, projeto, config) numa tacada
   dd-harness login --token <token> [--api <url>]
                                      guarda a credencial desta máquina
   dd-harness projeto <slug> --nome "<nome>" [--tenant <t>] [--api <url>]
@@ -71,6 +78,142 @@ function argumento(argv, nome) {
     const i = argv.indexOf(`--${nome}`);
     return i >= 0 ? argv[i + 1] : undefined;
 }
+const API_PADRAO = "https://dd-harness.vercel.app";
+/**
+ * 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".
+ */
+function tentaAbrirNavegador(url) {
+    const comando = process.platform === "win32" ? "start" : process.platform === "darwin" ? "open" : "xdg-open";
+    try {
+        spawn(comando, process.platform === "win32" ? ["", url] : [url], {
+            shell: process.platform === "win32",
+            stdio: "ignore",
+            detached: true,
+        }).unref();
+    }
+    catch {
+        // Segue sem navegador — a URL impressa antes desta chamada ja resolve.
+    }
+}
+/**
+ * `dd-harness start` — o wizard para pasta vazia.
+ *
+ * Ate aqui, comecar um projeto exigia saber de memoria a sequencia certa
+ * (`projeto` -> `init` -> copiar tres blocos de JSON) e o slug do tenant. `start`
+ * conduz tudo numa tacada, perguntando so o que falta.
+ *
+ * Reverte "sugerir, nunca escrever" para `.claude/settings.json` e `.mcp.json` — decisao
+ * tomada de proposito aqui, ao contrario de `init`, que continua so sugerindo. O preco e
+ * o merge cuidadoso em `escreve-config.ts`: nunca perder o que a pessoa ja tinha.
+ */
+async function comandoStart() {
+    const caminhoConfig = join(process.cwd(), CAMINHO_CONFIG);
+    try {
+        await access(caminhoConfig);
+        throw new Error(`este repositório já tem ${CAMINHO_CONFIG} — start é só para pasta vazia. ` +
+            "Use `dd-harness init` para ajustar um projeto já existente.");
+    }
+    catch (erro) {
+        if (erro instanceof Error && erro.message.includes("já tem"))
+            throw erro;
+        // ENOENT: exatamente o caso esperado, segue.
+    }
+    console.log("Iniciando o dd-harness nesta pasta.\n");
+    // 1. Credencial. Sem ela nada do resto e possivel — nem listar tenant.
+    let token = await leToken(API_PADRAO);
+    if (!token) {
+        console.log(`Sem credencial salva para ${API_PADRAO}.`);
+        token = await pergunta("Cole o token pessoal (crie um em /tokens na interface): ");
+        await guardaToken(API_PADRAO, token);
+        console.log("Credencial guardada.\n");
+    }
+    // 2. Espaco (tenant). Criar um e ato de dono — nunca por aqui — mas ESCOLHER entre
+    // os que ja existem e so leitura, e e o que faltava para nao exigir o slug de memoria.
+    let tenants = await listaTenants(API_PADRAO, token);
+    while (tenants.length === 0) {
+        const url = `${API_PADRAO}/tenants`;
+        console.log(`\nVocê ainda não participa de nenhum espaço. Abrindo ${url} ...`);
+        tentaAbrirNavegador(url);
+        await pergunta("Crie um espaço lá e volte aqui. Pressione Enter para continuar: ");
+        tenants = await listaTenants(API_PADRAO, token);
+    }
+    const tenant = await escolha("\nEscolha um espaço:", tenants.map((t) => ({ rotulo: `${t.nome} (${t.slug})`, valor: t.slug })));
+    // 3. Projeto. Criar e subordinado a estar num espaco — isso o CLI ja faz sozinho.
+    const nomeSugerido = process.cwd().split(/[\\/]/).pop() ?? "meu-projeto";
+    const nome = (await pergunta(`\nNome do projeto [${nomeSugerido}]: `)) || nomeSugerido;
+    // Nome so com caracteres especiais (ex: "!!!") normaliza para string vazia — o
+    // fallback evita sugerir slug vazio, que o servidor recusaria com erro confuso.
+    const slugSugerido = nome
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[̀-ͯ]/g, "")
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || "meu-projeto";
+    const slugDoProjeto = (await pergunta(`Identificador curto (slug) [${slugSugerido}]: `)) || slugSugerido;
+    const resultadoProjeto = await criaProjeto(process.cwd(), slugDoProjeto, nome, {
+        tenant,
+        api: API_PADRAO,
+    });
+    console.log(resultadoProjeto.jaExistia
+        ? `\nProjeto ${resultadoProjeto.projeto} já existia — usando ele.`
+        : `\nProjeto ${resultadoProjeto.projeto} criado.`);
+    // 4. Config do repositorio — o unico arquivo que `init` tambem escreveria.
+    const r = await init(process.cwd(), { tenant, projeto: resultadoProjeto.projeto, api: API_PADRAO });
+    console.log(r.config === "criada" ? `criado  ${CAMINHO_CONFIG}` : `mantido ${CAMINHO_CONFIG}`);
+    // 5. Hook e MCP — ESCRITOS, com merge. E aqui que `start` diverge de `init`.
+    const hook = await escreveHook(process.cwd());
+    if (!hook.ok) {
+        console.log(`\nAVISO: ${hook.caminho} não é um JSON válido — não toquei nele. ` +
+            "Acrescente manualmente:\n");
+        console.log(SUGESTAO_HOOK);
+    }
+    else {
+        console.log({ criado: "criado  .claude/settings.json (hook adicionado)",
+            "ja-tinha": "mantido .claude/settings.json — hook já estava lá",
+            acrescentado: "atualizado .claude/settings.json (hook adicionado ao que já existia)",
+        }[hook.estado]);
+    }
+    const mcp = await escreveMcp(process.cwd());
+    if (!mcp.ok) {
+        console.log(`\nAVISO: ${mcp.caminho} não é um JSON válido — não toquei nele. ` +
+            "Acrescente manualmente:\n");
+        console.log(SUGESTAO_MCP);
+    }
+    else {
+        console.log({ criado: "criado  .mcp.json (servidor dd-harness adicionado)",
+            "ja-tinha": "mantido .mcp.json — servidor já estava declarado",
+            acrescentado: "atualizado .mcp.json (servidor adicionado ao que já existia)",
+        }[mcp.estado]);
+    }
+    // 6. AGENTS.md — so quem usa outra ferramenta alem do Claude Code precisa.
+    const outraFerramenta = await pergunta("\nVai abrir este projeto em Codex, Cursor ou outra ferramenta além do Claude " +
+        "Code? [s/N]: ");
+    if (/^s/i.test(outraFerramenta)) {
+        const agents = await escreveAgents(process.cwd());
+        console.log({ criado: "criado  AGENTS.md",
+            "ja-tinha": "mantido AGENTS.md — já apontava para a política",
+            acrescentado: "atualizado AGENTS.md (instrução acrescentada ao que já existia)",
+        }[agents.estado]);
+    }
+    // 7. Onde esta o monorepo do worker nesta maquina? So pergunta uma vez, e so importa
+    // se houver memoria na fila agora — pular aqui nao trava nada, so avisa mais vezes.
+    const semWorkerConfigurado = !(await temWorkerConfigurado());
+    if (semWorkerConfigurado) {
+        const caminho = await pergunta("\nO worker de embeddings roda local (não hospedado). Onde está o repositório " +
+            "`dd-harness_new` clonado nesta máquina? (Enter para pular — o hook vai " +
+            "avisar quando precisar): ");
+        if (caminho)
+            await guardaConfigDaMaquina({ workerRepo: caminho });
+    }
+    fechaPerguntas();
+    console.log("\nPronto. Abra uma sessão do Claude Code nesta pasta — a política vai ser o " +
+        "primeiro assunto.");
+}
+async function temWorkerConfigurado() {
+    const { workerRepo } = await leConfigDaMaquina();
+    return Boolean(workerRepo);
+}
 async function comandoInit(argv) {
     const tenant = argumento(argv, "tenant");
     const projeto = argumento(argv, "projeto");
@@ -316,7 +459,9 @@ async function comandoPolitica(argv) {
         return;
     }
     if (r.estado === "sem-politica") {
-        console.error("Este projeto ainda não tem política — nunca foi briefado. Rode `/briefar`.");
+        console.error("Este projeto ainda não tem política e/ou briefing — os dois são obrigatórios. " +
+            "Rode uma sessão com `--hook` (ou converse com o agente): ele vai conduzir o " +
+            "briefing agora e escrever os dois.");
         process.exitCode = 3;
         return;
     }
@@ -345,9 +490,23 @@ function contextoDaSessao(r, worker) {
     if (r.estado === "sem-politica") {
         return {
             ...base,
-            additionalContext: "AVISO DO DD-HARNESS: este projeto existe no serviço mas **nunca foi briefado** " +
-                "— não há política.\n\nIsto não é uma falha: é um projeto novo. Antes de " +
-                "implementar qualquer coisa, diga isso ao usuário e proponha rodar `/briefar`." +
+            additionalContext: "AVISO DO DD-HARNESS: este projeto existe no serviço mas política e/ou " +
+                "briefing **estão faltando** — os dois são obrigatórios.\n\n" +
+                "Isto não é uma falha: é um projeto novo. Antes de implementar qualquer " +
+                "coisa, conduza o briefing agora, nesta sessão:\n\n" +
+                "1. Se houver um `CLAUDE.md` na raiz deste repositório, leia-o primeiro — o " +
+                "que ele já diz é ponto de partida, não é para ser ignorado.\n" +
+                "2. Pergunte ao usuário o que o código e o `CLAUDE.md` não revelarem: " +
+                "objetivo do projeto, stack principal, restrições e convenções.\n" +
+                "3. Mostre o rascunho da política e do briefing e espere a confirmação " +
+                "explícita do usuário antes de escrever.\n" +
+                "4. Escreva os dois com a ferramenta MCP `escrever_artefato` " +
+                "(`tipo: \"politica\"` e `tipo: \"briefing\"`, uma chamada cada). Se essa " +
+                "ferramenta não estiver disponível nesta sessão, pare e diga ao usuário que " +
+                "o servidor MCP do dd-harness precisa estar conectado para isto.\n" +
+                "5. Depois de escrever os dois, sobrescreva o `CLAUDE.md` da raiz com um " +
+                "ponteiro curto para a política deste serviço — a verdade passa a morar " +
+                "aqui, e o `CLAUDE.md` local nunca mais precisa ser editado à mão." +
                 fila,
         };
     }
@@ -511,6 +670,8 @@ async function principal() {
         return;
     }
     switch (comando) {
+        case "start":
+            return comandoStart();
         case "init":
             return comandoInit(resto);
         case "login":

package/dist/cli/src/pergunta.js

@@ -0,0 +1,31 @@
+import { createInterface } from "node:readline/promises";
+/**
+ * Leitura de terminal, so para `dd-harness start`.
+ *
+ * O resto do CLI e puramente por flag — nao interativo de proposito, porque script e
+ * gancho (`post-commit`, CI) nao tem ninguem para responder um prompt. `start` e a
+ * excecao deliberada: e o comando de quem esta sentado no terminal, comecando um
+ * projeto do zero, sem saber os slugs de memoria.
+ */
+let rl = null;
+function interfaceAtual() {
+    return (rl ??= createInterface({ input: process.stdin, output: process.stdout }));
+}
+export async function pergunta(texto) {
+    return (await interfaceAtual().question(texto)).trim();
+}
+export function fechaPerguntas() {
+    rl?.close();
+    rl = null;
+}
+/** Numera as opcoes, pede um numero, devolve o item escolhido. Sem loop de retry: erra, recomeca o comando — start nao e ambiente para validar input ao infinito. */
+export async function escolha(titulo, itens) {
+    console.log(titulo);
+    itens.forEach((item, i) => console.log(`  ${i + 1}) ${item.rotulo}`));
+    const resposta = await pergunta("> ");
+    const indice = Number(resposta) - 1;
+    const escolhido = itens[indice];
+    if (!escolhido)
+        throw new Error(`escolha um número entre 1 e ${itens.length}.`);
+    return escolhido.valor;
+}

package/dist/cli/src/politica.js

@@ -24,9 +24,13 @@ export async function buscaPolitica(raiz) {
         const payload = (await resposta.json());
         const conteudo = payload.politica?.trim();
         const esperandoIndexacao = payload.esperando_indexacao ?? 0;
-        // Vazio e nulo sao a mesma coisa aqui, e os dois significam "nunca foi escrita".
-        if (!conteudo)
+        // `briefado` e do SERVICO, nao inferido aqui: exige politica E briefing, os dois
+        // obrigatorios. So checar `politica` vazia deixava passar o caso de politica
+        // existir sem briefing — a sessao seguia como "ok" com metade do briefing faltando,
+        // e nada acionava o fluxo que devia completa-lo.
+        if (!conteudo || payload.briefado === false) {
             return { estado: "sem-politica", esperandoIndexacao };
+        }
         return { estado: "ok", conteudo, esperandoIndexacao };
     }
     catch (erro) {

package/dist/cli/src/projeto.js

@@ -37,3 +37,14 @@ export async function criaProjeto(raiz, slug, nome, explicito = {}) {
     const { projeto } = (await resposta.json());
     return { projeto, jaExistia: false };
 }
+/**
+ * Os espacos (tenants) que este token alcanca — para `dd-harness start` deixar escolher
+ * em vez de exigir o slug de memoria.
+ */
+export async function listaTenants(api, token) {
+    const resposta = await pede(`${api}/api/v1/tenants`, { headers: cabecalhos(token) });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const { tenants } = (await resposta.json());
+    return tenants;
+}

package/dist/cli/src/worker.js

@@ -1,6 +1,7 @@
 import { spawn } from "node:child_process";
 import { access } from "node:fs/promises";
 import { join } from "node:path";
+import { leConfigDaMaquina } from "./config.js";
 /**
  * Subir o worker de embeddings quando ha fila esperando.
  *
@@ -14,19 +15,38 @@ import { join } from "node:path";
  *
  * - **So sobe quando ha fila.** O hook roda em TODA sessao, inclusive nas que so leem
  *   codigo. Subir com a fila vazia gastaria chamada de embedding sem ninguem ter pedido.
- * - **So no repositorio que TEM o worker.** Ele vive neste monorepo, nao no repositorio
- *   consumidor: la o `pnpm worker` nao existe, e tentar rodar daria erro a cada sessao.
+ * - **So quando sabemos ONDE esta o worker.** Ele vive no monorepo `dd-harness_new`, nao
+ *   no repositorio consumidor — que e onde este hook roda na pratica. Achar o monorepo
+ *   custou uma medicao real: a primeira versao so checava `raiz` (o cwd de quem chamou),
+ *   entao so funcionava quando o dd-harness era executado de DENTRO do proprio monorepo
+ *   — nunca no caso real, que e o projeto do usuario noutra pasta.
  */
-/** O worker vive aqui dentro. Noutro repositorio, nao ha o que subir. */
-export async function temWorkerLocal(raiz) {
+/** O worker existe nesta pasta especifica? */
+async function ehOMonorepo(caminho) {
     try {
-        await access(join(raiz, "src", "worker", "indexador.ts"));
+        await access(join(caminho, "src", "worker", "indexador.ts"));
         return true;
     }
     catch {
         return false;
     }
 }
+/**
+ * Onde rodar o worker, se soubermos.
+ *
+ * Prioridade: `~/.dd-harness/config.json` (`workerRepo`, salvo por `dd-harness start` ou
+ * `dd-harness worker --configurar`) primeiro — e o caminho que vale em qualquer pasta que
+ * o CLI rode. Cai para `raiz` so por compatibilidade com quem já roda de dentro do
+ * monorepo sem ter configurado nada.
+ */
+export async function achaOWorker(raiz) {
+    const { workerRepo } = await leConfigDaMaquina();
+    if (workerRepo && (await ehOMonorepo(workerRepo)))
+        return workerRepo;
+    if (await ehOMonorepo(raiz))
+        return raiz;
+    return null;
+}
 /**
  * Dispara um lote e devolve na hora — nao espera terminar.
  *
@@ -41,12 +61,12 @@ export async function temWorkerLocal(raiz) {
 export async function subiuOWorker(raiz, esperando) {
     if (esperando <= 0)
         return { subiu: false, motivo: "sem-fila" };
-    if (!(await temWorkerLocal(raiz))) {
+    const repo = await achaOWorker(raiz);
+    if (!repo)
         return { subiu: false, motivo: "sem-worker" };
-    }
     try {
         const filho = spawn("npx", ["pnpm@latest", "worker", "--uma-vez"], {
-            cwd: raiz,
+            cwd: repo,
             detached: true,
             stdio: "ignore",
             shell: process.platform === "win32",

package/dist/mcp/src/index.js

@@ -34,20 +34,25 @@ const falha = (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.
+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.`;
+/**
+ * A regra e recusada pelo CLI e pela API — esta descricao existe para o agente acertar de
+ * primeira, em vez de descobrir no erro.
+ */
+const ACENTUACAO = `Escreva em pt-BR com acentuação correta — título, resumo e corpo. Isto NÃO é estilo: o texto vira embedding, e a mesma frase sem acento cai para ~0,94 de similaridade. Com o acervo em grafia misturada, a busca passa a premiar quem escreve igual à consulta em vez de quem é relevante. Texto sem acento é RECUSADO na gravação; nada é corrigido automaticamente, porque adivinhar entre \`e\`/\`é\` gravaria conteúdo adulterado em silêncio.`;
 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, use \`ler_memoria\` com o endereço. O Brain não existe em disco: nada de procurar arquivo.
-
-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.
-
+        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, use \`ler_memoria\` com o endereço. O Brain não existe em disco: nada de procurar arquivo.
+
+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
@@ -81,15 +86,17 @@ Os primeiros achados são os que valem: o piso barra tema alheio, mas num Brain
         }
     });
     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.
+        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}
+
+${ACENTUACAO}
+
+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
@@ -108,10 +115,10 @@ A pasta precisa existir antes — use \`criar_pasta\`. Essa recusa é deliberada
         }
     });
     server.registerTool("ler_memoria", {
-        description: `Devolve uma memória inteira — corpo, filtros e âncoras — pelo endereço \`<pasta>/<slug>\`.
-
-Use depois de \`buscar_memoria\`, que devolve só título e resumo: é aqui que está o conteúdo. O Brain não vive em disco, então este é o único caminho para o corpo — não procure arquivo.
-
+        description: `Devolve uma memória inteira — corpo, filtros e âncoras — pelo endereço \`<pasta>/<slug>\`.
+
+Use depois de \`buscar_memoria\`, que devolve só título e resumo: é aqui que está o conteúdo. O Brain não vive em disco, então este é o único caminho para o corpo — não procure arquivo.
+
 Também é o ponto de partida obrigatório de \`editar_memoria\`: o formato devolvido é o mesmo que ela consome.`,
         inputSchema: z.object({
             endereco: z
@@ -128,11 +135,13 @@ Também é o ponto de partida obrigatório de \`editar_memoria\`: o formato devo
         }
     });
     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).
-
-Comece por \`ler_memoria\`: ela devolve exatamente este formato, e o Brain não existe em disco — sem ler antes, você estaria reescrevendo de memória e apagaria o que não lembrasse. Salve o resultado num arquivo, edite, e passe o caminho aqui.
-
-Os três filtros continuam valendo na edição — o banco recusa igual. ${FILTROS}`,
+        description: `Corrige uma memória que já existe, pelo mesmo formato markdown de \`gravar_memoria\`. O endereço sai do frontmatter (pasta + name).
+
+Comece por \`ler_memoria\`: ela devolve exatamente este formato, e o Brain não existe em disco — sem ler antes, você estaria reescrevendo de memória e apagaria o que não lembrasse. Salve o resultado num arquivo, edite, e passe o caminho aqui.
+
+Os três filtros continuam valendo na edição — o banco recusa igual. ${FILTROS}
+
+${ACENTUACAO}`,
         inputSchema: z.object({
             arquivo: z
                 .string()
@@ -149,8 +158,8 @@ Os três filtros continuam valendo na edição — o banco recusa igual. ${FILTR
         }
     });
     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.
-
+        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
@@ -176,12 +185,12 @@ Use \`substituida_por\` quando outra memória toma o lugar desta — a troca aco
         }
     });
     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.
-
+        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
@@ -206,10 +215,10 @@ O ESPAÇO (tenant) não se cria por aqui, de propósito: ele é a fronteira de i
         }
     });
     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.
-
+        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
@@ -233,11 +242,11 @@ Criar uma que já existe não é erro: devolve que já existia, sem alterar a de
         }
     });
     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.
-
+        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
@@ -257,10 +266,10 @@ Devolve vazio quando o artefato ainda não existe. Vazio não é erro: projeto n
         }
     });
     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.
-
+        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

package/package.json

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