dd-harness 0.30.0 → 0.32.0

package/dist/edicoes.js

@@ -0,0 +1,52 @@
+import { resolve } from "node:path";
+const texto = (v) => typeof v === "string" ? v : undefined;
+export function normalizaEntrada(host, entrada) {
+    if (host === "antigravity") {
+        const roots = entrada.workspacePaths;
+        if (!Array.isArray(roots) || roots.length !== 1 || typeof roots[0] !== "string") {
+            throw new Error("dd-harness exige um workspace inequívoco por sessão; selecione um projeto.");
+        }
+        const chamada = entrada.toolCall;
+        return { raiz: roots[0], sessao: texto(entrada.conversationId) ?? "", ferramenta: chamada?.name ?? "",
+            args: chamada?.args ?? {} };
+    }
+    return { raiz: texto(entrada.cwd) ?? process.cwd(), sessao: texto(entrada.session_id) ?? "",
+        ferramenta: texto(entrada.tool_name) ?? "", args: (entrada.tool_input ?? {}) };
+}
+export function edicoesDaChamada(c) {
+    const a = c.args;
+    if (c.ferramenta === "apply_patch") {
+        const patch = texto(a.command) ?? texto(a.patch) ?? "";
+        const edicoes = [];
+        let atual;
+        for (const linha of patch.split(/\r?\n/)) {
+            const inicio = /^\*\*\* (Update|Add|Delete) File: (.+)$/.exec(linha);
+            if (inicio) {
+                atual = { arquivo: resolve(c.raiz, inicio[2]), antes: inicio[1] === "Delete" ? undefined : "", depois: "" };
+                edicoes.push(atual);
+            }
+            else if (atual && linha.startsWith("*** Move to: ")) {
+                // Renomear afeta o arquivo inteiro, inclusive trechos fora dos hunks.
+                atual.antes = undefined;
+                edicoes.push({ arquivo: resolve(c.raiz, linha.slice(13)), origem: atual.arquivo });
+            }
+            else if (atual && !linha.startsWith("***")) {
+                if (atual.antes !== undefined && (linha.startsWith("-") || linha.startsWith(" ")))
+                    atual.antes += linha.slice(1) + "\n";
+                if (linha.startsWith("+") || linha.startsWith(" "))
+                    atual.depois += linha.slice(1) + "\n";
+            }
+        }
+        return edicoes;
+    }
+    const arquivo = texto(a.file_path) ?? texto(a.TargetFile) ?? texto(a.Path);
+    if (!arquivo)
+        return [];
+    const chunks = a.ReplacementChunks ?? a.edits;
+    if (Array.isArray(chunks))
+        return chunks.map(chunk => ({ arquivo: resolve(c.raiz, arquivo),
+            antes: texto(chunk.TargetContent ?? chunk.old_string), depois: texto(chunk.ReplacementContent ?? chunk.new_string) }));
+    return [{ arquivo: resolve(c.raiz, arquivo),
+            antes: texto(a.old_string) ?? texto(a.TargetContent),
+            depois: texto(a.new_string) ?? texto(a.content) ?? texto(a.ReplacementContent) ?? texto(a.CodeContent) }];
+}

package/dist/escreve-config.d.ts

@@ -50,3 +50,4 @@ export declare function escrevePonteiro(raiz: string, arquivo: "AGENTS.md" | "CL
 export declare const escreveAgents: (raiz: string) => Promise<{
     estado: "criado" | "ja-tinha" | "acrescentado";
 }>;
+export declare const SUGESTAO_AGENTS = "## Protocolo do dd-harness\n\nEste projeto tem um protocolo de trabalho que **n\u00E3o est\u00E1 neste arquivo**.\n\n**ANTES de qualquer outra coisa**, chame a ferramenta MCP `ler_artefato` com\n`tipo: \"politica\"` e siga o que ela devolver. \u00C9 a primeira a\u00E7\u00E3o da sess\u00E3o, antes\nde ler c\u00F3digo, responder ou planejar.\n\n- Se a ferramenta n\u00E3o existir, o servidor MCP do dd-harness n\u00E3o est\u00E1 declarado:\n  avise o usu\u00E1rio e **n\u00E3o modifique nada** at\u00E9 ele resolver.\n- Se ela devolver vazio, este projeto nunca foi briefado \u2014 diga isso ao usu\u00E1rio.\n\nLeia tamb\u00E9m o briefing com a mesma ferramenta (tipo briefing). Os dois s\u00E3o obrigat\u00F3rios.\n\nDepois, `ler_roadmap`: se houver uma fase **Agora**, \u00E9 dela que saem os passos\ndesta sess\u00E3o. Lista vazia significa que este projeto n\u00E3o usa roadmap, e isso \u00E9\nv\u00E1lido \u2014 n\u00E3o crie fase sem o usu\u00E1rio pedir.\n\nE `listar_skills`: s\u00E3o os procedimentos deste projeto. **Invoque a que couber\nANTES de fazer o trabalho, n\u00E3o depois** \u2014 skill lida no fim vira revis\u00E3o do que\nj\u00E1 saiu errado, e \u00E9 tarde.\n\nVale mesmo quando o pedido parece pequeno: \"\u00E9 s\u00F3 um ajuste\" \u00E9 exatamente a\nfrase que antecede pular o procedimento. A pol\u00EDtica diz quais s\u00E3o obrigat\u00F3rias\ne quando.";

package/dist/escreve-config.js

@@ -112,7 +112,7 @@ export async function escrevePonteiro(raiz, arquivo) {
 }
 /** Compatibilidade: `init` ainda chama pelo nome antigo. */
 export const escreveAgents = (raiz) => escrevePonteiro(raiz, "AGENTS.md");
-const SUGESTAO_AGENTS = `## Protocolo do dd-harness
+export const SUGESTAO_AGENTS = `## Protocolo do dd-harness
 
 Este projeto tem um protocolo de trabalho que **não está neste arquivo**.
 
@@ -124,10 +124,16 @@ de ler código, responder ou planejar.
   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.
 
-Depois, \`ler_roadmap\`: se houver uma fase **Agora**, é dela que saem os passos
+Leia também o briefing com a mesma ferramenta (tipo briefing). Os dois são obrigatórios.
+
+Depois, \`ler_roadmap\`: se houver uma fase **Agora**, é dela que saem os passos
 desta sessão. Lista vazia significa que este projeto não usa roadmap, e isso é
 válido — não crie fase sem o usuário pedir.
 
 E \`listar_skills\`: são os procedimentos deste projeto. **Invoque a que couber
 ANTES de fazer o trabalho, não depois** — skill lida no fim vira revisão do que
-já saiu errado. A política diz quais são obrigatórias e quando.`;
+já saiu errado, e é tarde.
+
+Vale mesmo quando o pedido parece pequeno: "é só um ajuste" é exatamente a
+frase que antecede pular o procedimento. A política diz quais são obrigatórias
+e quando.`;

package/dist/estado-local.d.ts

@@ -0,0 +1,7 @@
+/** Override explícito para testes e instalações isoladas; nunca troca HOME do processo. */
+export declare const diretorioDoUsuario: () => string;
+export declare function estadoDoRepo(raiz: string): string;
+export declare function revisaoDoContexto(raiz: string): Promise<string>;
+export declare function invalidaContexto(raiz: string): Promise<void>;
+/** Leitores veem o JSON anterior ou o novo, nunca um arquivo parcialmente escrito. */
+export declare function escreveAtomico(caminho: string, conteudo: string): Promise<void>;

package/dist/estado-local.js

@@ -0,0 +1,33 @@
+import { createHash, randomUUID } from "node:crypto";
+import { mkdir, rename, writeFile, rm, readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+/** Override explícito para testes e instalações isoladas; nunca troca HOME do processo. */
+export const diretorioDoUsuario = () => process.env.DD_HARNESS_HOME ?? join(homedir(), ".dd-harness");
+export function estadoDoRepo(raiz) {
+    const caminho = resolve(raiz);
+    const chave = createHash("sha256").update(process.platform === "win32" ? caminho.toLowerCase() : caminho).digest("hex");
+    return join(diretorioDoUsuario(), "repos", chave);
+}
+export async function revisaoDoContexto(raiz) {
+    return readFile(join(estadoDoRepo(raiz), "contexto-revisao"), "utf8").catch((e) => {
+        if (e.code === "ENOENT")
+            return "";
+        throw e;
+    });
+}
+export async function invalidaContexto(raiz) {
+    await escreveAtomico(join(estadoDoRepo(raiz), "contexto-revisao"), randomUUID());
+}
+/** Leitores veem o JSON anterior ou o novo, nunca um arquivo parcialmente escrito. */
+export async function escreveAtomico(caminho, conteudo) {
+    await mkdir(dirname(caminho), { recursive: true });
+    const temporario = `${caminho}.${randomUUID()}.tmp`;
+    try {
+        await writeFile(temporario, conteudo, { encoding: "utf8", mode: 0o600 });
+        await rename(temporario, caminho);
+    }
+    finally {
+        await rm(temporario, { force: true });
+    }
+}

package/dist/gravar.js

@@ -1,7 +1,7 @@
+import { invalidaCache } from "./cinto.js";
 import { readFile } from "node:fs/promises";
 import { recusaPorAcentuacao } from "./acentuacao.js";
-import { cabecalhos, credencial, pede, recusa } from "./api.js";
-import { acrescentaAoCache } from "./cinto.js";
+import { jsonDaEscrita, 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.
@@ -188,19 +188,9 @@ export async function grava(raiz, caminho) {
     });
     if (!resposta.ok)
         await recusa(resposta);
-    const { endereco } = (await resposta.json());
-    // O cinto passa a enxergar esta memoria AGORA, nao na proxima sessao. Sem isto, a
-    // memoria recem-gravada nao protegia nada ate a sessao seguinte — medido na rodada 006,
-    // e justamente no fluxo mais comum: gravar a decisao e, minutos depois, alguem tentar
-    // desfazer o que ela guarda.
-    await acrescentaAoCache(raiz, {
-        pasta: memoria.pasta,
-        slug: memoria.slug,
-        titulo: memoria.titulo,
-        resumo: memoria.resumo,
-        status: "ativa",
-        ancoras: memoria.ancoras.map((valor) => ({ tipo: "caminho", valor, sha: null })),
-    });
+    await invalidaCache(raiz);
+    const { endereco } = (await jsonDaEscrita(resposta));
+    // A próxima edição atualiza o cache inteiro, incluindo outras memórias e globais.
     return {
         endereco,
         ancoras: memoria.ancoras.length,

package/dist/hosts.d.ts

@@ -0,0 +1,6 @@
+import type { Host } from "./edicoes.js";
+export declare const HOSTS: Host[];
+export declare function selecionaHosts(valor?: string): Host[];
+export declare function hostsInstalados(raiz: string): Promise<Host[]>;
+/** Cada host usa seu formato. Configuração alheia não é inferida como gerenciada. */
+export declare function instalaHosts(raiz: string, hosts: Host[]): Promise<string[]>;

package/dist/hosts.js

@@ -0,0 +1,129 @@
+import { readFile, mkdir } from "node:fs/promises";
+import { dirname, join, resolve } from "node:path";
+import { escreveAtomico, estadoDoRepo } from "./estado-local.js";
+import { escrevePonteiro, SUGESTAO_AGENTS } from "./escreve-config.js";
+export const HOSTS = ["claude", "codex", "antigravity"];
+export function selecionaHosts(valor = "claude") {
+    const nomes = valor === "todos" ? HOSTS : valor.split(",");
+    if (nomes.some(n => !HOSTS.includes(n)))
+        throw new Error("host: use claude, codex, antigravity ou todos");
+    return [...new Set(nomes)];
+}
+export async function hostsInstalados(raiz) {
+    try {
+        return selecionaHosts(JSON.parse(await readFile(join(estadoDoRepo(raiz), "hosts.json"), "utf8")).join(","));
+    }
+    catch {
+        return [];
+    }
+}
+function objeto(v) {
+    if (v === undefined)
+        return {};
+    if (!v || typeof v !== "object" || Array.isArray(v))
+        throw new Error("estrutura de configuração inválida");
+    return v;
+}
+async function json(caminho, altera) {
+    const atual = await readFile(caminho, "utf8").catch((e) => {
+        if (e.code === "ENOENT")
+            return "{}";
+        throw e;
+    });
+    const doc = objeto(JSON.parse(atual));
+    altera(doc);
+    const novo = JSON.stringify(doc, null, 2) + "\n";
+    if (atual !== novo)
+        await escreveAtomico(caminho, novo);
+}
+function grupo(doc, evento, command, antigos = []) {
+    const grupos = doc[evento] ?? [];
+    if (!Array.isArray(grupos))
+        throw new Error(`hooks.${evento} precisa ser lista`);
+    const preservados = grupos.map(g => {
+        if (!g || typeof g !== "object" || !Array.isArray(g.hooks))
+            throw new Error(`hook ${evento} inválido`);
+        return { ...g, hooks: g.hooks.filter((h) => ![command, ...antigos].includes(h.command ?? "")) };
+    }).filter(g => g.hooks.length);
+    preservados.push({ hooks: [{ type: "command", command, timeout: 60 }] });
+    doc[evento] = preservados;
+}
+/** Cada host usa seu formato. Configuração alheia não é inferida como gerenciada. */
+export async function instalaHosts(raiz, hosts) {
+    raiz = resolve(raiz);
+    const avisos = [];
+    const mcp = { command: "npx", args: ["-y", "dd-harness-mcp@latest"], env: { DD_HARNESS_ROOT: raiz } };
+    for (const host of hosts) {
+        if (host === "codex") {
+            const caminho = join(raiz, ".codex", "config.toml");
+            const atual = await readFile(caminho, "utf8").catch((e) => {
+                if (e.code === "ENOENT")
+                    return "";
+                throw e;
+            });
+            if (atual.includes("dd-harness")) {
+                avisos.push("Codex: servidor já configurado; preservado. Confira command e DD_HARNESS_ROOT com diagnostico.");
+            }
+            else {
+                await escreveAtomico(caminho, atual + `\n[mcp_servers.dd-harness]\ncommand = "npx"\nargs = ["-y", "dd-harness-mcp@latest"]\nstartup_timeout_sec = 60\n[mcp_servers.dd-harness.env]\nDD_HARNESS_ROOT = ${JSON.stringify(raiz)}\n`);
+            }
+            await json(join(raiz, ".codex", "hooks.json"), doc => {
+                const h = objeto(doc.hooks);
+                doc.hooks = h;
+                grupo(h, "SessionStart", "dd-harness sessao --host codex");
+                grupo(h, "PreToolUse", "dd-harness guarda --host codex");
+            });
+            avisos.push("Codex: abra /hooks e confira a confiança dos hooks; arquivos instalados não comprovam ativação.");
+        }
+        else {
+            await json(join(raiz, host === "claude" ? ".mcp.json" : ".agents/mcp_config.json"), doc => {
+                const servidores = objeto(doc.mcpServers);
+                doc.mcpServers = servidores;
+                if (servidores["dd-harness"])
+                    avisos.push(`${host}: MCP existente preservado; confira a raiz no diagnóstico.`);
+                else
+                    servidores["dd-harness"] = mcp;
+            });
+            if (host === "claude") {
+                await json(join(raiz, ".claude/settings.json"), doc => {
+                    const h = objeto(doc.hooks);
+                    doc.hooks = h;
+                    grupo(h, "SessionStart", "dd-harness sessao --host claude", ["dd-harness politica --hook"]);
+                    grupo(h, "PreToolUse", "dd-harness guarda --host claude", ["dd-harness cinto"]);
+                });
+            }
+            else {
+                await json(join(raiz, ".agents/hooks.json"), doc => {
+                    const bloco = objeto(doc["dd-harness"]);
+                    const handlers = bloco.PreInvocation ?? [];
+                    if (!Array.isArray(handlers))
+                        throw new Error("PreInvocation precisa ser lista; configuração preservada");
+                    const comando = "dd-harness sessao --host antigravity";
+                    if (doc["dd-harness"] && !handlers.some(h => h?.command === comando)) {
+                        throw new Error("hook dd-harness já existe com conteúdo alheio; preservado");
+                    }
+                    bloco.PreInvocation = [...handlers.filter(h => h?.command !== comando), { type: "command", command: comando, timeout: 60 }];
+                    grupo(bloco, "PreToolUse", "dd-harness guarda --host antigravity");
+                    doc["dd-harness"] = bloco;
+                });
+                const regra = join(raiz, ".agents/rules/dd-harness.md");
+                const atual = await readFile(regra, "utf8").catch((e) => {
+                    if (e.code === "ENOENT")
+                        return null;
+                    throw e;
+                });
+                const conteudo = "---\ntrigger: always_on\n---\n\n" + SUGESTAO_AGENTS;
+                if (atual === null)
+                    await escreveAtomico(regra, conteudo);
+                else if (atual !== conteudo)
+                    avisos.push("Antigravity: regra local existente preservada; revise a entrada de protocolo.");
+            }
+        }
+    }
+    await mkdir(dirname(join(raiz, "AGENTS.md")), { recursive: true });
+    await escrevePonteiro(raiz, "AGENTS.md");
+    if (hosts.includes("claude"))
+        await escrevePonteiro(raiz, "CLAUDE.md");
+    await escreveAtomico(join(estadoDoRepo(raiz), "hosts.json"), JSON.stringify([...new Set([...await hostsInstalados(raiz), ...hosts])]));
+    return avisos;
+}

package/dist/index.js

@@ -1,7 +1,12 @@
 #!/usr/bin/env node
+import { diagnostico } from "./diagnostico.js";
+import { instalaHosts, selecionaHosts } from "./hosts.js";
+import { achaRaiz } from "./config.js";
+import { abreSessao, guardaSessao, saidaDaGuarda, saidaDoBoot } from "./sessao.js";
 import { spawn } from "node:child_process";
 import { access, readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
+const DIRETORIO_DA_INVOCACAO = process.cwd();
 // DEP0190: Node imprime esse warning direto no stderr no instante em que
 // `spawn(..., { shell: true })` recebe um array de args — de forma sincrona, ANTES de
 // qualquer listener rodar, entao filtrar dentro de um `process.on("warning")` normal nao
@@ -14,10 +19,9 @@ process.removeAllListeners("warning");
 import { termosDaConsulta } from "./argv.js";
 import { check, status } from "./check.js";
 import { CAMINHO_CONFIG, guardaConfigDaMaquina, guardaToken, leConfigDaMaquina, leConfigDoRepo, leToken, } from "./config.js";
-import { escreveHook, escreveMcp, escrevePonteiro } from "./escreve-config.js";
 import { escreveGanchoDeCommit, iniciaRepositorio } from "./git.js";
 import { grava } from "./gravar.js";
-import { init, SUGESTAO_AGENTS, SUGESTAO_HOOK, SUGESTAO_MCP } from "./init.js";
+import { init } from "./init.js";
 import { pergunta, escolha, fechaPerguntas } from "./pergunta.js";
 import { buscaPolitica } from "./politica.js";
 import { avisoDeOrdem, blocoDeSessao, criaFase, editaFase, formataChangelog, formataRoadmap, leFases, } from "./roadmap.js";
@@ -30,8 +34,9 @@ import { criaPasta } from "./pasta.js";
 import { criaProjeto, listaTenants } from "./projeto.js";
 import { reancora } from "./reancorar.js";
 import { subiuOWorker } from "./worker.js";
+import { REGRA_DE_COMMITS } from "./regras-de-commit.js";
 /**
- * `dd-harness` — o cliente que materializa os artefatos no repositorio.
+ * `dd-harness` — o cliente de política, memória e integrações de hosts.
  *
  * Sem dependencia de proposito: `fetch`, `crypto` e `fs` sao do Node, e o molde original
  * ja seguia a regra de validador determinístico sem dependencia. Um CLI que vive pinado
@@ -40,14 +45,18 @@ 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,
+  dd-harness diagnostico [--mcp]    confere projeto, contexto e conexão MCP
+  dd-harness integrar --host todos  instala MCP/regras/hooks em projeto existente
+  dd-harness sessao --host <host>    hook de boot (stdin JSON)
+  dd-harness guarda --host <host>    hook antes de ferramentas (stdin JSON)
+  dd-harness start [--host <host>]   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>]
                                      cria o projeto no serviço (antes do init)
   dd-harness init --tenant <t> --projeto <p> [--api <url>]
-                                     prepara o repositório (config + CLAUDE.md)
+                                     escreve .dd-harness.json; depois rode integrar
   dd-harness pasta <slug> --definicao "o que entra e o que não entra"
                                      cria a pasta que o gravar exige
   dd-harness gravar <arquivo.md>     registra uma memória a partir de um markdown
@@ -94,8 +103,9 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
   dd-harness --help
   dd-harness --version              qual binário está instalado nesta máquina
 
-Nada do dd-harness fica em disco: a política chega pelo hook de sessão, e a
-memória pela busca, na hora.
+Política e briefing chegam do serviço. O disco guarda configuração, ponteiros
+para skills e estado descartável em ~/.dd-harness. Hosts: claude, codex,
+antigravity, lista separada por vírgulas ou todos.
 `;
 /**
  * Os ganchos sao IMPRESSOS, nunca instalados. `.git/hooks` nao e versionado e nao e
@@ -111,8 +121,7 @@ Opcional — o gancho que devolve a memória ao code review:
 
 Termina em sucesso mesmo com deriva: avisa, não bloqueia.
 
-O hook da política (\`dd-harness politica --hook\`) é outra coisa, e não é
-opcional — \`dd-harness init\` imprime a linha para o \`.claude/settings.json\`.`;
+Instale os hooks de sessão e guarda com \`dd-harness integrar --host <host>\`.`;
 function argumento(argv, nome) {
     const i = argv.indexOf(`--${nome}`);
     return i >= 0 ? argv[i + 1] : undefined;
@@ -173,7 +182,7 @@ function statusDoArgv(argv) {
 /** `--conteudo` aponta para um .md, como `gravar` e `editar` — markdown de verdade nao cabe em flag. */
 async function conteudoDoArgv(argv) {
     const caminho = argumento(argv, "conteudo");
-    return caminho === undefined ? undefined : readFile(caminho, "utf8");
+    return caminho === undefined ? undefined : readFile(resolve(DIRETORIO_DA_INVOCACAO, caminho), "utf8");
 }
 /**
  * `fase criar` e `fase editar`. Concluir uma fase e `fase editar <slug> --status concluida`
@@ -338,7 +347,8 @@ function mascara(token) {
  * 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() {
+async function comandoStart(argv) {
+    const hosts = selecionaHosts(argumento(argv, "host"));
     const caminhoConfig = join(process.cwd(), CAMINHO_CONFIG);
     try {
         await access(caminhoConfig);
@@ -452,54 +462,13 @@ async function comandoStart() {
     // 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]);
-    }
-    if (mcp.ok) {
-        console.log("\nInstalando a versão mais recente do servidor dd-harness-mcp " +
-            "(a primeira vez pode demorar um pouco)...");
-        const { ok: instalou, erro: erroInstalacao } = await instalaMcp();
-        console.log(instalou
-            ? "dd-harness-mcp instalado — a próxima sessão do Claude Code conecta na hora."
-            : `AVISO: não consegui pré-instalar dd-harness-mcp (${erroInstalacao}). A primeira ` +
-                "conexão do Claude Code pode demorar ou falhar; se falhar, abra uma nova sessão " +
-                "e tente de novo.");
-    }
-    // 6. CLAUDE.md e AGENTS.md — os dois SEMPRE, sem perguntar. Sao espelhos: o mesmo
-    // apontamento para o servico, cada um na porta que uma familia de ferramenta le. A
-    // pergunta "usa outra ferramenta?" saiu porque a resposta nao muda nada que valha a
-    // pena — quem responde "nao" hoje abre o repositorio no Cursor semana que vem e nao
-    // encontra protocolo nenhum, e o custo de ja ter o arquivo e um ponteiro de 8 linhas.
-    console.log("");
-    for (const arquivo of ["CLAUDE.md", "AGENTS.md"]) {
-        const r = await escrevePonteiro(process.cwd(), arquivo);
-        console.log({ criado: `criado  ${arquivo}`,
-            "ja-tinha": `mantido ${arquivo} — já apontava para a política`,
-            acrescentado: `atualizado ${arquivo} (apontamento acrescentado ao que já existia)`,
-        }[r.estado]);
-    }
+    const avisos = await instalaHosts(process.cwd(), hosts);
+    console.log('Integrações instaladas: ' + hosts.join(', '));
+    for (const aviso of avisos)
+        console.log('AVISO: ' + aviso);
+    const instalacao = await instalaMcp();
+    if (!instalacao.ok)
+        console.log('AVISO: MCP não pré-instalado; execute diagnostico antes de usar.');
     // 6.5. Os ponteiros das skills do projeto.
     //
     // O Claude Code descobre skill lendo `.claude/skills/*/SKILL.md` na ABERTURA da sessao,
@@ -518,7 +487,9 @@ async function comandoStart() {
         }
         const skills = await leSkills(process.cwd());
         if (skills.length > 0) {
-            const { escritos } = await escrevePonteirosDeSkills(process.cwd(), skills);
+            const { escritos, conflitos } = await escrevePonteirosDeSkills(process.cwd(), skills, hosts.map(h => h === "claude" ? ".claude" : ".agents"));
+            if (conflitos.length)
+                console.log("Ponteiros preservados por conflito: " + conflitos.join(", "));
             console.log(escritos > 0
                 ? `escritos ${escritos} ponteiro(s) de skill em .claude/skills/`
                 : `${skills.length} skill(s) — ponteiros já estavam em dia`);
@@ -558,38 +529,7 @@ async function comandoInit(argv) {
     });
     console.log(r.config === "criada" ? "criado  .dd-harness.json" : "mantido .dd-harness.json");
     console.log("\nAgora: dd-harness login --token <token>");
-    // O hook vem primeiro e nao e opcional: sem ele a sessao abre sem politica, que e a
-    // falha que este projeto existe para combater. O MCP e conveniencia; este, nao.
-    if (r.hook === "ja-declarado") {
-        console.log("\nmantido .claude/settings.json — o hook da política já está declarado");
-    }
-    else {
-        console.log("\nOBRIGATÓRIO: o hook que carrega a política no início de cada sessão." +
-            "\nSem ele a sessão abre sem protocolo, e nada avisa. Acrescente ao" +
-            "\n`.claude/settings.json` (não escrevo nele: o arquivo é seu e pode já" +
-            "\nter hooks e permissões):\n");
-        console.log(SUGESTAO_HOOK);
-    }
-    if (r.mcp === "ja-declarado") {
-        console.log("\nmantido .mcp.json — o servidor dd-harness já está declarado");
-    }
-    else {
-        console.log("\nOpcional: as memórias como ferramenta, para o agente buscar e gravar sem" +
-            "\nescrever arquivo. Acrescente ao `.mcp.json` da raiz (não escrevo nele: o" +
-            "\narquivo é seu e pode declarar outros servidores):\n");
-        console.log(SUGESTAO_MCP);
-    }
-    // Fora do Claude Code o hook nao roda, e ai o MCP deixa de ser conveniencia: e o unico
-    // caminho da politica. Mas ferramenta disponivel nao e ferramenta chamada — sem esta
-    // instrucao, o agente pode nunca perguntar.
-    if (r.agents === "ja-aponta") {
-        console.log("\nmantido AGENTS.md — já manda buscar a política pelo MCP");
-        return;
-    }
-    console.log("\nUsa Codex, Cursor, Gemini CLI ou Windsurf? Eles NÃO rodam o hook do" +
-        "\nClaude Code, e sem isto a sessão abre sem política. Crie um `AGENTS.md`" +
-        "\nna raiz (ou acrescente ao seu) com:\n");
-    console.log(SUGESTAO_AGENTS);
+    console.log("\nConfigure MCP, hooks e ponteiros: dd-harness integrar --host claude,codex,antigravity");
 }
 /**
  * Nao exige `.dd-harness.json`, e isso importa: sem projeto no servico o `init` nao tem o
@@ -612,7 +552,7 @@ async function comandoEditar(argv) {
     if (!caminho || caminho.startsWith("-")) {
         throw new Error("uso: dd-harness editar <arquivo.md>");
     }
-    const r = await edita(process.cwd(), caminho);
+    const r = await edita(process.cwd(), resolve(DIRETORIO_DA_INVOCACAO, caminho));
     console.log(`editado  ${r.endereco}`);
     console.log(`  ${r.ancoras} âncora(s).`);
 }
@@ -993,6 +933,7 @@ function contextoDaSessao(r, worker) {
                 "`reset --hard`, reescrever história publicada. Ficam fora por padrão.\n" +
                 "   Escreva cada resposta como regra. \"Ele sabe o que pode\" não sobrevive à " +
                 "próxima sessão, que começa sem memória disto.\n" +
+                "   Inclua também esta convenção nos commits:\n" + REGRA_DE_COMMITS + "\n\n" +
                 "4. Mostre o rascunho da política e do briefing e espere a confirmação " +
                 "explícita do usuário antes de escrever.\n" +
                 "5. Escreva os dois com a ferramenta MCP `escrever_artefato` " +
@@ -1164,7 +1105,7 @@ async function comandoGravar(argv) {
     if (!caminho || caminho.startsWith("-")) {
         throw new Error("uso: dd-harness gravar <arquivo.md>");
     }
-    const r = await grava(process.cwd(), caminho);
+    const r = await grava(process.cwd(), resolve(DIRETORIO_DA_INVOCACAO, caminho));
     console.log(`gravado  ${r.endereco}`);
     console.log(`  ${r.ancoras} âncora(s), valendo para ${r.projetos} projeto(s).`);
 }
@@ -1199,9 +1140,12 @@ async function principal() {
         console.log(AJUDA);
         return;
     }
+    if (comando && !["start", "init", "login", "projeto", "sessao", "guarda", "--help", "-h", "--version", "-V", "version"].includes(comando)) {
+        process.chdir(await achaRaiz());
+    }
     switch (comando) {
         case "start":
-            return comandoStart();
+            return comandoStart(resto);
         case "init":
             return comandoInit(resto);
         case "login":
@@ -1232,6 +1176,35 @@ async function principal() {
             return comandoCheck(resto);
         case "status":
             return comandoStatus();
+        case "diagnostico":
+            console.log((await diagnostico(process.cwd(), resto.includes("--mcp"))).join("\n"));
+            break;
+        case "integrar": {
+            const hosts = selecionaHosts(argumento(resto, "host") ?? "todos");
+            for (const aviso of await instalaHosts(process.cwd(), hosts))
+                console.log(aviso);
+            console.log("Integrações configuradas: " + hosts.join(", "));
+            break;
+        }
+        case "sessao":
+        case "guarda": {
+            const host = selecionaHosts(argumento(resto, "host"))[0];
+            try {
+                let cru = "";
+                for await (const chunk of process.stdin) {
+                    cru += chunk;
+                    if (cru.length > 2000000)
+                        throw new Error("Entrada de hook grande demais");
+                }
+                const entrada = JSON.parse(cru);
+                console.log(JSON.stringify(comando === "sessao" ? await abreSessao(host, entrada) : await guardaSessao(host, entrada)));
+            }
+            catch (e) {
+                const motivo = e instanceof Error ? e.message : String(e);
+                console.log(JSON.stringify(comando === "guarda" ? saidaDaGuarda(host, motivo) : saidaDoBoot(host, motivo, false)));
+            }
+            break;
+        }
         case "politica":
             return comandoPolitica(resto);
         case "cinto":

package/dist/pasta.js

@@ -1,4 +1,4 @@
-import { cabecalhos, credencial, pede, recusa } from "./api.js";
+import { jsonDaEscrita, cabecalhos, credencial, pede, recusa } from "./api.js";
 /**
  * `dd-harness pasta <slug> --definicao "..."` — cria a pasta sem sair da sessao.
  *
@@ -25,6 +25,6 @@ export async function criaPasta(raiz, slug, definicao) {
         return { pasta: slug, jaExistia: true };
     if (!resposta.ok)
         await recusa(resposta);
-    const { pasta } = (await resposta.json());
+    const { pasta } = (await jsonDaEscrita(resposta));
     return { pasta, jaExistia: false };
 }

package/dist/politica.js

@@ -1,4 +1,5 @@
 import { cabecalhos, credencial, pede } from "./api.js";
+import { politicaParaSessao } from "./regras-de-commit.js";
 export async function buscaPolitica(raiz) {
     let config;
     try {
@@ -29,10 +30,11 @@ export async function buscaPolitica(raiz) {
         // 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) {
+        if (!conteudo || payload.briefado === false || !payload.briefing?.trim()) {
             return { estado: "sem-politica", esperandoIndexacao, memorias: payload.memorias };
         }
-        return { estado: "ok", conteudo, esperandoIndexacao, roadmap, memorias: payload.memorias };
+        return { estado: "ok", conteudo: politicaParaSessao(conteudo) + "\n\n# Briefing do projeto\n\n" + payload.briefing,
+            esperandoIndexacao, roadmap, memorias: payload.memorias };
     }
     catch (erro) {
         return { estado: "inalcancavel", motivo: mensagem(erro) };

package/dist/projeto.js

@@ -1,4 +1,4 @@
-import { cabecalhos, pede, recusa } from "./api.js";
+import { jsonDaEscrita, cabecalhos, pede, recusa } from "./api.js";
 import { leConfigDoRepo, leToken } from "./config.js";
 /**
  * `dd-harness projeto <slug> --nome "..."` — cria o projeto sem sair da sessao.
@@ -34,7 +34,7 @@ export async function criaProjeto(raiz, slug, nome, explicito = {}) {
         return { projeto: slug, jaExistia: true };
     if (!resposta.ok)
         await recusa(resposta);
-    const { projeto } = (await resposta.json());
+    const { projeto } = (await jsonDaEscrita(resposta));
     return { projeto, jaExistia: false };
 }
 /**

package/dist/regras-de-commit.d.ts

@@ -0,0 +1,3 @@
+/** Regra do produto, entregue junto da política sem reescrever o artefato no serviço. */
+export declare const REGRA_DE_COMMITS = "## Identifica\u00E7\u00E3o do agente nos commits\n\nTodo commit feito por agente come\u00E7a com [IDENTIFICA\u00C7\u00C3O] - tipo: descri\u00E7\u00E3o.\nExemplos: [CODEX] - feat: nova funcionalidade; [CLAUDE] - fix: corrige a busca;\n[GEMINI] - docs: atualiza o guia. Outro agente usa seu nome em mai\u00FAsculas entre colchetes.\nIdentifique o agente/modelo que efetivamente realizou o commit, n\u00E3o apenas o editor:\nClaude no Antigravity continua [CLAUDE]; Gemini usa [GEMINI]; Codex usa [CODEX].\nN\u00E3o invente a identidade. A regra n\u00E3o concede autoriza\u00E7\u00E3o para commitar, n\u00E3o altera\no autor do Git e n\u00E3o pede reescrita de commits antigos.";
+export declare function politicaParaSessao(conteudo: string): string;