dd-harness 0.35.0 → 0.37.0

package/dist/atualizar.d.ts

@@ -21,6 +21,18 @@ export type Item = {
  * maquina, nao por projeto).
  */
 export declare function diagnosticaAtualizacao(raiz: string, versaoInstalada: string, versaoPublicada: string | null): Promise<Item[]>;
+/**
+ * Incorpora ao projeto as skills iniciais escolhidas pelo usuario.
+ *
+ * Recebe os slugs em vez de criar tudo que falta, e essa e a diferenca que importa: skill
+ * pode ter sido apagada de proposito, e criar a lista inteira desfaria a decisao de quem
+ * apagou. Quem chama aqui e a skill `atualizar-harness`, depois do "sim" a cada uma.
+ */
+export declare function incorporaSkills(raiz: string, slugs: string[]): Promise<{
+    criadas: string[];
+    falharam: string[];
+    ponteiros: string;
+}>;
 /**
  * Aplica so os itens marcados `aplicar`. Os de `perguntar` ficam intactos de proposito —
  * quem decide sobre arquivo editado a mao e o dono dele.

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,121 @@ 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.
+    //
+    // `perguntar`, nunca `aplicar`: skill PODE ser apagada, entao do lado de fora "nasceu
+    // depois deste projeto" e "eu apaguei porque nao quero" sao indistinguiveis — e recriar
+    // sozinho desfaria a segunda em silencio, toda vez que alguem rodasse o comando. Quem
+    // sabe qual dos dois e o dono; o diagnostico so mostra o que falta e para que serve.
+    let doServico = null;
+    try {
+        doServico = await leSkills(raiz);
+    }
+    catch {
+        // So a REDE cai aqui. O que vem depois e disco, e misturar os dois no mesmo try faz um
+        // erro de leitura de arquivo ser reportado como "o serviço não respondeu" — mentira que
+        // manda procurar o problema no lugar errado.
+        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" });
+    }
+    if (doServico) {
+        const existentes = new Set(doServico.map(s => s.slug));
+        const faltando = SKILLS_INICIAIS.filter(s => !existentes.has(s.slug));
+        // Sem ponteiro em disco, a skill EXISTE no servico e nenhum host a descobre — o Claude
+        // Code le `.claude/skills/*/SKILL.md` na abertura da sessao. Some por apagar o .md ou
+        // por renomear a pasta, e some CALADA: `dd-harness skills` continua listando a skill,
+        // entao a unica pista e ela nunca ser invocada. Caso diferente do de baixo, e este se
+        // resolve sozinho: reescrever o ponteiro nao desfaz decisao nenhuma sobre a skill.
+        const destinos = [...new Set((await hostsInstalados(raiz))
+                .map(h => h === "claude" ? ".claude" : ".agents"))];
+        const semPonteiro = [];
+        for (const skill of doServico) {
+            for (const destino of destinos.length ? destinos : [".claude"]) {
+                // No `.agents` a skill so-por-comando nao ganha ponteiro de proposito: ausencia ali
+                // e desenho, nao perda.
+                if (destino === ".agents" && skill.so_por_comando)
+                    continue;
+                // So ENOENT conta como "sem ponteiro". Permissao negada ou disco com erro nao e
+                // ponteiro faltando, e tratar como se fosse mandaria reescrever por cima de um
+                // problema que e outro.
+                const existe = await readFile(join(raiz, destino, "skills", skill.slug, "SKILL.md"), "utf8")
+                    .then(() => true)
+                    .catch((e) => { if (e.code === "ENOENT")
+                    return false; throw e; });
+                if (!existe) {
+                    semPonteiro.push(`${destino}/skills/${skill.slug}`);
+                }
+            }
+        }
+        if (semPonteiro.length) {
+            itens.push({
+                o_que: "ponteiros de skill",
+                situacao: `${semPonteiro.length} skill(s) do serviço sem arquivo em disco`,
+                acao: "aplicar",
+                detalhe: `${semPonteiro.join(", ")} — o host não descobre a skill sem o ponteiro; será reescrito`,
+            });
+        }
+        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) não estão neste projeto`,
+                acao: "perguntar",
+                // A descricao inteira, nao so o slug: e o campo que diz QUANDO a skill serve, e
+                // sem ele a pergunta vira "quer `revisar-memoria`?" — que ninguem responde bem.
+                detalhe: faltando.map(s => `${s.slug}: ${s.descricao}`).join("\n"),
+            });
+    }
     return itens;
 }
+/** Reescreve em disco os ponteiros das skills que o serviço tem. */
+async function reescrevePonteiros(raiz) {
+    const destinos = [...new Set((await hostsInstalados(raiz))
+            .map(h => h === "claude" ? ".claude" : ".agents"))];
+    const r = await escrevePonteirosDeSkills(raiz, await leSkills(raiz), destinos.length ? destinos : [".claude"]);
+    return `ponteiros de skill: ${r.escritos} reescrito(s)` +
+        (r.conflitos.length ? `; ${r.conflitos.length} preservado(s) por edição local` : "");
+}
+/**
+ * Incorpora ao projeto as skills iniciais escolhidas pelo usuario.
+ *
+ * Recebe os slugs em vez de criar tudo que falta, e essa e a diferenca que importa: skill
+ * pode ter sido apagada de proposito, e criar a lista inteira desfaria a decisao de quem
+ * apagou. Quem chama aqui e a skill `atualizar-harness`, depois do "sim" a cada uma.
+ */
+export async function incorporaSkills(raiz, slugs) {
+    const criadas = [];
+    const falharam = [];
+    for (const slug of slugs) {
+        const inicial = SKILLS_INICIAIS.find(s => s.slug === slug);
+        if (!inicial) {
+            falharam.push(`${slug} (não é uma skill inicial)`);
+            continue;
+        }
+        try {
+            await criaSkill(raiz, inicial);
+            criadas.push(slug);
+        }
+        catch (erro) {
+            // Uma que nao entrou nao impede as outras: metade incorporada e melhor que nenhuma,
+            // e o retorno diz qual faltou e por que.
+            falharam.push(`${slug} (${erro instanceof Error ? erro.message : String(erro)})`);
+        }
+    }
+    // Sem o ponteiro em disco a skill existe no servico e host nenhum a descobre; criar e
+    // parar aqui entregaria uma skill invisivel ate o boot seguinte.
+    let ponteiros = "";
+    if (criadas.length) {
+        ponteiros = await reescrevePonteiros(raiz)
+            .catch(() => "ponteiros NÃO escritos — rode `dd-harness atualizar --aplicar` ou reabra a sessão");
+    }
+    return { criadas, falharam, 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 +199,16 @@ 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 === "ponteiros de skill") {
+            // Seguro no `--aplicar`: reescrever o ponteiro de uma skill que o servico tem nao
+            // decide nada sobre a skill — so devolve ao host a chance de descobri-la.
+            try {
+                feitos.push(await reescrevePonteiros(raiz));
+            }
+            catch (erro) {
+                feitos.push(`ponteiros de skill: NÃO aplicado (${erro instanceof Error ? erro.message : String(erro)})`);
+            }
+        }
     }
     return feitos;
 }

package/dist/index.js

@@ -545,7 +545,17 @@ async function comandoAtualizar(argv) {
     const itens = await diagnosticaAtualizacao(raiz, await versaoInstalada(import.meta.url), await versaoPublicada(AbortSignal.timeout(6000)));
     const simbolo = { "em-dia": "ok  ", aplicar: "->  ", perguntar: "??  ", manual: "!   " };
     for (const i of itens) {
-        console.log(`${simbolo[i.acao]}${i.o_que}: ${i.situacao}${i.detalhe ? ` — ${i.detalhe}` : ""}`);
+        // Detalhe multilinha (as descrições das skills que faltam) vira bloco indentado: numa
+        // linha só, a descrição de cada skill some no meio das outras, e é justamente ela que
+        // responde se a skill vale para este projeto.
+        if (i.detalhe?.includes("\n")) {
+            console.log(`${simbolo[i.acao]}${i.o_que}: ${i.situacao}`);
+            for (const linha of i.detalhe.split("\n"))
+                console.log(`      ${linha}`);
+        }
+        else {
+            console.log(`${simbolo[i.acao]}${i.o_que}: ${i.situacao}${i.detalhe ? ` — ${i.detalhe}` : ""}`);
+        }
     }
     const aAplicar = itens.filter(i => i.acao === "aplicar");
     const aPerguntar = itens.filter(i => i.acao === "perguntar");
@@ -559,13 +569,13 @@ async function comandoAtualizar(argv) {
         for (const linha of await aplicaAtualizacao(raiz, itens))
             console.log(linha);
     }
-    // Estes ficam de fora do `--aplicar` de proposito: o arquivo foi editado a mao, e so o
-    // dono sabe se a edicao dele continua valendo depois da mudanca do molde.
+    // Estes ficam de fora do `--aplicar` de proposito: o arquivo foi editado a mao, ou a
+    // skill pode ter sido apagada de proposito — e so o dono sabe qual dos dois.
     if (aPerguntar.length) {
         console.log(`\n${aPerguntar.length} item(ns) NÃO foram tocados por exigirem decisão sua:`);
         for (const i of aPerguntar)
-            console.log(`  ${i.o_que}: ${i.detalhe ?? i.situacao}`);
-        console.log("  Use a skill atualizar-harness para conduzir esses casos.");
+            console.log(`  ${i.o_que}: ${i.situacao}`);
+        console.log("  Use a skill atualizar-harness: ela apresenta cada caso e pergunta.");
     }
 }
 async function comandoInit(argv) {

package/dist/skills-iniciais.js

@@ -543,9 +543,37 @@ cria o arquivo que não existe. O que está fora do bloco não é lido nem reesc
 
 Os itens \`??\` ficam intactos de propósito — o comando não os toca.
 
-## 4. Conduza os casos que exigem decisão
+## 4a. Skills que faltam: apresente e pergunte, uma a uma
 
-Para cada item \`??\`, faça o trabalho que o comando não pode fazer:
+O item \`?? skills\` lista as skills iniciais que **não estão** neste projeto. Elas caem em
+dois casos que, de fora, são **indistinguíveis**:
+
+- **Nasceu depois deste projeto.** A semeadura só roda em projeto sem skill alguma, então
+  skill nova nunca chega sozinha a um projeto que já existe.
+- **Foi apagada de propósito.** Skill é apagável, e quem apagou tomou uma decisão.
+
+**Nunca recrie sem perguntar.** Incorporar a lista inteira desfaz a segunda decisão em
+silêncio, e desfaz de novo a cada vez que alguém rodar o comando.
+
+Para cada skill faltante, apresente ao usuário:
+
+1. **O nome e o que ela faz** — o diagnóstico já imprime a descrição completa; ela é o
+   campo que diz *quando* a skill serve
+2. **Por que ela pode importar aqui**, com base neste projeto: a stack, o que existe no
+   repositório, o que o BRIEFING diz. "Este projeto tem Brain com âncoras, então
+   \`resolver-deriva\` teria uso" vale mais que repetir a descrição
+3. **A pergunta**: incorporar esta?
+
+Aceite "não" sem insistir. Uma skill recusada é uma decisão do dono, não um item pendente —
+e se ele disser "não" para a mesma skill de novo no mês que vem, isso é sinal de que a
+resposta já está dada.
+
+Com a lista do que ele aceitou, incorpore só essas. Os ponteiros em disco são escritos
+junto; sem eles a skill existe no serviço e host nenhum a descobre.
+
+## 4b. Conduza os outros casos que exigem decisão
+
+Para cada item \`??\` restante, faça o trabalho que o comando não pode fazer:
 
 1. **Mostre ao usuário o que está lá** e o que o molde novo traz.
 2. **Diga o que você acha que aconteceu** — "parece que você acrescentou esta linha

package/package.json

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