dd-harness 0.33.2 → 0.35.0

package/dist/index.js

@@ -56,7 +56,12 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
   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
+                                     espaço, projeto, config) numa tacada.
+                                     Instala os TRÊS hosts por padrão (claude,
+                                     codex, antigravity) — cada um escreve no
+                                     arquivo que a sua ferramenta lê, sem
+                                     conflito. Use --host claude,codex para
+                                     limitar
   dd-harness login --token <token> [--api <url>]
                                      guarda a credencial desta máquina
   dd-harness projeto <slug> --nome "<nome>" [--tenant <t>] [--api <url>]
@@ -354,7 +359,13 @@ function mascara(token) {
  * o merge cuidadoso em `escreve-config.ts`: nunca perder o que a pessoa ja tinha.
  */
 async function comandoStart(argv) {
-    const hosts = selecionaHosts(argumento(argv, "host"));
+    // Todos os hosts por padrao, como o `integrar` ja fazia. Instalar so o Claude obrigava
+    // quem abrisse o mesmo repositorio no Codex a descobrir sozinho que faltava um comando —
+    // e o projeto so descobre isso quando o outro host ja esta aberto e sem protocolo.
+    // Configuracao de host nao e escolha do dia da criacao: e a porta que CADA ferramenta
+    // usa, e as tres escrevem em arquivos diferentes, sem conflito. `--host` continua
+    // aceitando a lista explicita para quem quiser menos.
+    const hosts = selecionaHosts(argumento(argv, "host") ?? "todos");
     const caminhoConfig = join(process.cwd(), CAMINHO_CONFIG);
     try {
         await access(caminhoConfig);
@@ -496,8 +507,9 @@ async function comandoStart(argv) {
             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(", "));
+            const destinos = [...new Set(hosts.map(h => h === "claude" ? ".claude" : ".agents"))];
             console.log(escritos > 0
-                ? `escritos ${escritos} ponteiro(s) de skill em .claude/skills/`
+                ? `escritos ${escritos} ponteiro(s) de skill em ${destinos.map(d => d + "/skills/").join(" e ")}`
                 : `${skills.length} skill(s) — ponteiros já estavam em dia`);
         }
     }

package/dist/skills-iniciais.js

@@ -575,4 +575,129 @@ que estava fora do bloco continua intacto** — é a garantia que o usuário que
 Se o projeto tem git, sugira conferir o diff antes de commitar. Não commite: o projeto é
 do usuário e as regras de commit dele são dele.`,
     },
+    {
+        slug: "revisar-memoria",
+        descricao: `Investiga se memórias antigas do Brain ainda são verdadeiras e traz um parecer com evidência, para você decidir. Invoque quando quiser fazer uma faxina do Brain, quando o status mostrar revisão vencida, ou quando desconfiar que alguma decisão registrada envelheceu. Só investiga e relata — nunca edita, arquiva ou apaga nada.`,
+        ferramentas: ["mcp__dd-harness__ler_memoria", "mcp__dd-harness__buscar_memoria", "Read", "Grep", "Glob", "WebSearch", "WebFetch", "Bash(dd-harness status:*)", "Bash(dd-harness check:*)", "Bash(dd-harness ler:*)", "Bash(git log:*)", "Bash(git diff:*)"],
+        so_por_comando: true,
+        dica_de_argumento: "[pasta/slug para revisar uma só, ou vazio para varrer o acervo]",
+        conteudo: `# Revisar memória
+
+A deriva pega a memória cujo **código** mudou. Esta skill existe para a outra — a que
+ninguém olha há muito tempo e cuja **razão** pode ter morrido sem deixar rastro no
+repositório: o fornecedor mudou o limite, o bug de terceiro foi corrigido, a exigência de
+compliance caiu, a lib passou a fazer nativamente o que a memória ensina a contornar.
+
+Nenhum \`check\` acusa isso. O alvo está intacto; é o mundo que mudou.
+
+## A regra que não se quebra
+
+**Você não edita, não arquiva e não apaga. Nada.** Esta skill investiga e apresenta o
+caso; quem decide é o usuário, na conversa.
+
+Isso não é cautela decorativa: arquivar tira a memória de circulação, e quem vier depois
+não saberá que ela existiu se você errar. O custo dos dois erros é assimétrico — manter
+uma memória morta custa uma linha de índice; apagar uma viva custa o incidente que ela
+evitava, e ninguém vai ligar uma coisa à outra.
+
+## Idade não é veredito
+
+O critério tentador é "ninguém revisitou há muito tempo, logo não serve". **Está errado, e
+o ROADMAP deste projeto já registra por quê:** contagem baixa correlaciona com *raridade*,
+não com inutilidade — a memória que protege contra o erro raro e catastrófico é a que tem
+a contagem mais baixa de todas.
+
+Então idade é **motivo para olhar**, nunca argumento no parecer. Se o único fundamento que
+você tiver para propor a saída de uma memória for "é antiga", **você não tem fundamento**:
+relate como "continua valendo" e siga.
+
+## 1. Escolha as candidatas
+
+Com \`pasta/slug\` no argumento, é aquela — pule para o passo 2.
+
+Sem argumento, monte a lista nesta ordem:
+
+1. \`dd-harness status\` — as que ele já aponta como **revisão vencida** entram primeiro
+2. Memórias antigas que **nunca** tiveram deriva (código estável ao redor: é exatamente
+   onde esta skill enxerga o que o \`check\` não vê)
+3. As que citam **coisa de fora** — versão, fornecedor, limite, prazo, bug de terceiro:
+   são as que envelhecem sem avisar
+
+**Teto de cinco por rodada.** Cada memória é uma investigação de verdade; trazer quinze
+pareceres rasos é pior que trazer três com evidência, e o usuário não consegue decidir
+sobre quinze de uma vez.
+
+## 2. Leia a memória inteira — o porquê, não o título
+
+\`ler_memoria\`. A pergunta que governa tudo:
+
+> A razão que fez esta memória existir continua verdadeira **hoje**?
+
+Identifique de que tipo é a afirmação, porque cada uma se verifica num lugar diferente:
+
+| Tipo | Onde se confere |
+|---|---|
+| Sobre o código deste projeto | o próprio repositório |
+| Sobre lib, versão ou API | changelog, release notes, a doc atual |
+| Sobre fornecedor, limite ou contrato | a doc do fornecedor |
+| Sobre bug de terceiro | o issue: foi corrigido? |
+| Sobre decisão interna | o projeto ainda funciona assim? |
+
+## 3. Vá conferir — não opine
+
+Este é o passo que separa esta skill de um chute fundamentado.
+
+- **No repositório:** a âncora existe? O código ainda faz o que a memória descreve?
+  \`git log\` no alvo mostra que alguém mexeu naquilo?
+- **Fora:** quando a razão é externa, **procure a fonte**. Um \`WebSearch\` pela versão atual
+  da lib, pelo limite atual da API, pelo issue citado. Se a memória diz "a v3 não suporta
+  X" e a v5 suporta, isso é achado — e sem ir olhar você nunca saberia.
+
+Se não conseguir verificar, **diga que não conseguiu.** "Não achei fonte para confirmar o
+limite atual" é um parecer honesto e útil. Inventar uma conclusão para parecer produtivo é
+o pior resultado possível desta skill.
+
+## 4. Traga o parecer
+
+Um bloco por memória, na conversa. Curto, com a evidência à mostra:
+
+\`\`\`
+pasta/slug — Título
+
+  Diz: [a afirmação, em uma linha]
+  Verifiquei: [o que você foi olhar, com link/caminho/commit]
+  Achei: [o que encontrou de fato]
+  Parecer: continua valendo | envelheceu no texto | a razão pode ter morrido
+  Por quê: [o fundamento — nunca "é antiga"]
+\`\`\`
+
+Três pareceres possíveis, e nenhum é uma ação:
+
+**Continua valendo** — a razão está de pé. Diga isso e siga; não há trabalho a fazer.
+
+**Envelheceu no texto** — a razão continua, a descrição não bate mais. Mostre o trecho
+que está errado e o que seria o texto certo. O usuário decide se manda editar.
+
+**A razão pode ter morrido** — você encontrou evidência de que o motivo acabou. Mostre a
+evidência. Use "pode": você investigou, não sentenciou; pode haver contexto que a memória
+não registrou e o usuário conhece.
+
+Ao fim, uma linha só: quantas revisou, quantas continuam valendo, quantas merecem a
+atenção dele. Se nenhuma mereceu, **diga exatamente isso** — "revisei cinco, todas
+continuam valendo" é um resultado bom, não uma rodada perdida.
+
+## Nunca faça
+
+**Não proponha saída em lote.** Cinco memórias são cinco perguntas; um "essas cinco podem
+sair" é o mesmo que não ter investigado nenhuma.
+
+**Não use a data de revisão como argumento.** Ela é agenda, não julgamento. Uma memória
+vencida que você verificou e continua verdadeira é "continua valendo" — não "vencida".
+
+**Não confunda com deriva.** Se o achado é "o arquivo ancorado sumiu", isso é trabalho da
+\`resolver-deriva\`; diga ao usuário e aponte para lá em vez de resolver aqui.
+
+**Não vá pelo acervo inteiro.** O teto de cinco é o que mantém cada parecer com evidência.
+Fila é para ser processada aos poucos, e ela não vai a lugar nenhum.`,
+    },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-harness",
-  "version": "0.33.2",
+  "version": "0.35.0",
   "type": "module",
   "description": "Política, memória e integrações de Claude Code, Codex e Antigravity. CLI sem dependências de runtime.",
   "license": "UNLICENSED",