dd-harness 0.35.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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-harness",
-  "version": "0.35.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",