dd-harness 0.34.0 → 0.36.0

package/dist/atualizar.js

@@ -4,6 +4,9 @@ import { analisa } from "./bloco.js";
 import { MOLDES_HISTORICOS } from "./moldes-historicos.js";
 import { COMANDO_DO_CINTO, COMANDO_DO_HOOK, SUGESTAO_AGENTS, VERSAO_DO_MOLDE, escreveHook, escrevePonteiro } from "./escreve-config.js";
 import { versaoDoPacote } from "./versao.js";
+import { criaSkill, escrevePonteirosDeSkills, leSkills } from "./skill.js";
+import { hostsInstalados } from "./hosts.js";
+import { SKILLS_INICIAIS } from "./skills-iniciais.js";
 /**
  * `aplicar` e o que esta funcao pode fazer sozinha com seguranca; `perguntar` exige o dono
  * do arquivo; `manual` e o que nao se resolve de dentro do repositorio (o CLI global e por
@@ -64,8 +67,74 @@ export async function diagnosticaAtualizacao(raiz, versaoInstalada, versaoPublic
         ? { o_que: "hooks", situacao: "sessão e cinto declarados", acao: "em-dia" }
         : { o_que: "hooks", situacao: settings ? "incompletos ou legados" : "ausentes", acao: "aplicar",
             detalhe: "acrescenta sem duplicar nem tocar em hook de terceiro" });
+    // 4. Skills iniciais que nasceram depois deste projeto.
+    //
+    // A semeadura so roda em projeto SEM skill alguma, e o efeito colateral e que skill NOVA
+    // nunca alcanca projeto que ja existe: um projeto de dois meses atras ficou com as seis
+    // daquela epoca, e as que vieram depois so existiam em projeto criado do zero. Este item
+    // e o caminho que faltava.
+    //
+    // Skill inicial que falta e skill que NASCEU DEPOIS deste projeto — as padrao nao se
+    // apagam, entao ausencia aqui nao e decisao de ninguem, e recria-la nao desfaz nada.
+    // Por isso `aplicar`: e o mesmo caso do hook que faltava, e nao o do CLAUDE.md editado.
+    //
+    // A skill do projeto continua editavel: criar a que falta nao mexe em nenhuma existente,
+    // e o `criaSkill` erra de proposito se o slug ja existir.
+    try {
+        const existentes = new Set((await leSkills(raiz)).map(s => s.slug));
+        const faltando = SKILLS_INICIAIS.filter(s => !existentes.has(s.slug)).map(s => s.slug);
+        itens.push(faltando.length === 0
+            ? { o_que: "skills", situacao: `${existentes.size} no projeto; nenhuma inicial faltando`, acao: "em-dia" }
+            : {
+                o_que: "skills",
+                situacao: `${faltando.length} skill(s) inicial(is) nasceram depois deste projeto`,
+                acao: "aplicar",
+                detalhe: `${faltando.join(", ")} — serão criadas no serviço; as existentes não são tocadas`,
+            });
+    }
+    catch {
+        // Sem rede ou sem credencial: o resto do diagnostico continua valendo, e skill faltando
+        // nao e urgente o bastante para derrubar a checagem inteira.
+        itens.push({ o_que: "skills", situacao: "não consegui consultar o serviço", acao: "manual",
+            detalhe: "confira com `dd-harness skills` quando o serviço responder" });
+    }
     return itens;
 }
+/** Cria no serviço as skills iniciais que este projeto ainda não tem. */
+async function criaSkillsFaltantes(raiz) {
+    const existentes = new Set((await leSkills(raiz)).map(s => s.slug));
+    const faltando = SKILLS_INICIAIS.filter(s => !existentes.has(s.slug));
+    const criadas = [];
+    const falharam = [];
+    for (const inicial of faltando) {
+        try {
+            await criaSkill(raiz, inicial);
+            criadas.push(inicial.slug);
+        }
+        catch {
+            // Uma que nao entrou nao impede as outras: metade criada e melhor que nenhuma, e a
+            // linha de retorno diz exatamente qual faltou.
+            falharam.push(inicial.slug);
+        }
+    }
+    let ponteiros = "";
+    // A skill no servico nao e descoberta por host nenhum sem o ponteiro em disco: o Claude
+    // Code le `.claude/skills/*/SKILL.md` na abertura da sessao, e MCP nao fornece skill.
+    // Criar no servico e parar aqui entregaria uma skill que so aparece no boot seguinte.
+    if (criadas.length) {
+        try {
+            const hosts = await hostsInstalados(raiz);
+            const destinos = [...new Set(hosts.map(h => h === "claude" ? ".claude" : ".agents"))];
+            const r = await escrevePonteirosDeSkills(raiz, await leSkills(raiz), destinos.length ? destinos : [".claude"]);
+            ponteiros = `; ${r.escritos} ponteiro(s) em disco`;
+        }
+        catch {
+            ponteiros = "; ponteiros NÃO escritos — rode `dd-harness integrar` ou reabra a sessão";
+        }
+    }
+    return `skills: ${criadas.length} criada(s)${criadas.length ? " — " + criadas.join(", ") : ""}` +
+        (falharam.length ? `; FALHARAM: ${falharam.join(", ")}` : "") + ponteiros;
+}
 /**
  * Aplica so os itens marcados `aplicar`. Os de `perguntar` ficam intactos de proposito —
  * quem decide sobre arquivo editado a mao e o dono dele.
@@ -83,6 +152,14 @@ export async function aplicaAtualizacao(raiz, itens) {
             // um projeto que continua sem o cinto.
             feitos.push(r.ok ? `hooks: ${r.estado}` : `hooks: NÃO aplicado (${r.motivo})`);
         }
+        else if (item.o_que === "skills") {
+            try {
+                feitos.push(await criaSkillsFaltantes(raiz));
+            }
+            catch (erro) {
+                feitos.push(`skills: NÃO aplicado (${erro instanceof Error ? erro.message : String(erro)})`);
+            }
+        }
     }
     return feitos;
 }

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.34.0",
+  "version": "0.36.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",