dd-harness 0.38.2 → 0.40.0

package/dist/skill.d.ts

@@ -31,6 +31,11 @@ export declare function leSkill(raiz: string, slug: string): Promise<SkillComple
 export declare function criaSkill(raiz: string, dados: NovaSkillInicial & Partial<Pick<Skill, "so_por_comando" | "ferramentas" | "caminhos" | "dica_de_argumento">>): Promise<{
     skill: Skill;
 }>;
+/** Só o que muda: o que não vier fica como está no serviço. */
+export type EdicaoDeSkill = Partial<Pick<SkillCompleta, "descricao" | "conteudo" | "so_por_comando" | "ferramentas" | "caminhos" | "dica_de_argumento">>;
+export declare function editaSkill(raiz: string, slug: string, dados: EdicaoDeSkill): Promise<{
+    skill: Skill;
+}>;
 /**
  * O SKILL.md que vai para o disco: frontmatter de verdade, corpo que aponta para o MCP.
  *

package/dist/skill.js

@@ -38,6 +38,17 @@ dados) {
         await recusa(resposta);
     return (await jsonDaEscrita(resposta));
 }
+export async function editaSkill(raiz, slug, dados) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/skills/${encodeURIComponent(slug)}`, {
+        method: "PATCH",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({ tenant: config.tenant, projeto: config.projeto, ...dados }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await jsonDaEscrita(resposta));
+}
 // --- o ponteiro em disco (puro, para ser testado sem rede) ---
 /**
  * Escapa o que quebraria o YAML do frontmatter.
@@ -50,6 +61,22 @@ dados) {
 function comoEscalarYaml(texto) {
     return `"${texto.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, " ")}"`;
 }
+/**
+ * Um item de `allowed-tools` ou `paths`, limpo do que quebraria o frontmatter.
+ *
+ * Estas duas chaves sao listas separadas por virgula, e o host as le assim — entao nao da
+ * para citar o valor inteiro como se faz com `description`: as aspas entrariam no nome da
+ * ferramenta. O que sobra e neutralizar os tres caracteres que mudam a ESTRUTURA do YAML:
+ * quebra de linha (encerra o valor e a proxima linha vira chave nova), `:` seguido de
+ * espaco (o parser le chave) e a virgula (inventa um item que ninguem pediu).
+ *
+ * Importa porque estes itens vem da API, que aceita qualquer string nao vazia: um item com
+ * `\n` faz a skill sumir da lista ou ganhar uma chave que o host obedece — e frontmatter
+ * quebrado nao da erro visivel, exatamente como na `description`.
+ */
+function comoItemDeLista(texto) {
+    return texto.replace(/[\r\n]+/g, " ").replace(/:\s/g, " ").replace(/,/g, " ").trim();
+}
 /**
  * O SKILL.md que vai para o disco: frontmatter de verdade, corpo que aponta para o MCP.
  *
@@ -68,11 +95,18 @@ export function ponteiroDaSkill(skill, formato = "claude") {
     if (skill.dica_de_argumento) {
         frontmatter.push(`argument-hint: ${comoEscalarYaml(skill.dica_de_argumento)}`);
     }
-    const ferramentas = ["mcp__dd-harness__ler_skill", ...skill.ferramentas];
+    const ferramentas = [
+        "mcp__dd-harness__ler_skill",
+        ...skill.ferramentas.map(comoItemDeLista).filter(Boolean),
+    ];
     if (formato === "claude")
         frontmatter.push(`allowed-tools: ${ferramentas.join(", ")}`);
-    if (formato === "claude" && skill.caminhos.length > 0) {
-        frontmatter.push(`paths: ${skill.caminhos.join(", ")}`);
+    if (formato === "claude") {
+        const caminhos = skill.caminhos.map(comoItemDeLista).filter(Boolean);
+        // Depois da limpeza a lista pode ficar vazia (item que era so `\n`). `paths: ` sem
+        // valor nao e o mesmo que ausente: seria uma skill que nunca casa arquivo nenhum.
+        if (caminhos.length > 0)
+            frontmatter.push(`paths: ${caminhos.join(", ")}`);
     }
     frontmatter.push("---");
     return `${frontmatter.join("\n")}

package/dist/skills-iniciais.js

@@ -295,7 +295,7 @@ despromovida** — isso a deixaria invisível. Vincule-a a um projeto antes, ou
     {
         slug: "escrever-skill",
         descricao: `Escreve uma skill que o modelo de fato invoca e segue, em vez de uma que existe e nunca dispara. Invoque ao criar ou revisar uma skill deste projeto — ou quando notar que um procedimento já foi explicado três vezes e devia estar escrito.`,
-        ferramentas: ["mcp__dd-harness__listar_skills", "Read"],
+        ferramentas: ["mcp__dd-harness__listar_skills", "mcp__dd-harness__escrever_skill", "Read"],
         conteudo: `# Escrever uma skill que funciona
 
 A falha mais comum de skill não é estar errada — é **nunca disparar**. Ela existe, o
@@ -376,9 +376,15 @@ skill** — a ferramenta já ensina isso, e melhor.
 **Releia a descrição sozinha**, sem o corpo. Se você não souber dizer em que momento
 invocá-la, o modelo também não saberá.
 
-Skill deste projeto vive no serviço: o repositório guarda só o ponteiro, e o
-\`dd-harness start\` o reescreve. Se você mudou a descrição, rode-o — o frontmatter em
-disco não muda sozinho.`,
+## Gravar
+
+Skill deste projeto vive no serviço: o repositório guarda só o ponteiro. **Mostre a
+descrição e o corpo ao humano e grave só depois do OK**, com \`escrever_skill\` —
+\`criar: true\` para uma nova; sem ele, edita a existente. Na edição, mande só o que muda;
+\`conteudo\` substitui o procedimento inteiro, então leia antes com \`ler_skill\`.
+
+A ferramenta reescreve o ponteiro em disco. O procedimento novo vale na hora; descrição,
+ferramentas e caminhos são frontmatter, e o host só os relê na próxima sessão.`,
     },
     {
         slug: "propor-ferramentas",

package/dist/sync.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Busca o Brain e escreve em disco. Uma direcao so.
+ *
+ * O manifesto guarda o hash de cada arquivo que este comando escreveu. Antes de
+ * sobrescrever, ele confere: hash igual ao guardado significa "isto e meu, posso
+ * reescrever"; hash diferente significa que alguem editou a mao, e ai o comando **para**.
+ * Deriva silenciosa entre repo e servico e exatamente o que este projeto existe para
+ * evitar — melhor falhar alto do que engolir a edicao de alguem.
+ */
+/**
+ * Estado do ponteiro na raiz.
+ *
+ * `CLAUDE.md` nao e gerado — e do repositorio, e so precisa importar a politica. Mas o
+ * import falha em **silencio**: sem o arquivo alvo, ou sem a linha, a sessao abre e
+ * nada avisa que a politica nao veio junto. Foi medido, nao suposto. Como a sessao sem
+ * protocolo e a falha que o molde mais combate, o `sync` confere isso toda vez — mesmo
+ * quando o servico nao mudou, porque quem apaga a linha e quem mexe no repositorio.
+ */
+export type Ponteiro = "ok" | "sem-claude-md" | "sem-a-linha" | "sem-politica"
+/**
+ * A linha de import existe, mas nao ha politica no servico para ela apontar. O `init`
+ * escreve a linha antes de existir politica, entao o repositorio novo cai aqui: import
+ * pendurado desde o primeiro dia, e o mesmo silencio de sempre.
+ */
+ | "aponta-para-o-vazio";
+type Resultado = {
+    ponteiro: Ponteiro;
+} & ({
+    tipo: "sem-mudanca";
+} | {
+    tipo: "sincronizado";
+    escritos: string[];
+    removidos: string[];
+} | {
+    tipo: "editado-a-mao";
+    arquivos: string[];
+});
+/**
+ * Estado do que este comando escreveu, contra o hash guardado.
+ *
+ * Duas situacoes diferentes, e confundi-las custa caro: hash diferente e **edicao a
+ * mao**, e o comando tem que parar sem escrever; arquivo **ausente** nao e edicao — e
+ * trabalho a refazer, e o comando tem que reescrever.
+ */
+export declare function confereDisco(raiz: string, arquivos: Record<string, string>): Promise<{
+    editados: string[];
+    faltando: string[];
+}>;
+/**
+ * O `CLAUDE.md` da raiz existe e importa a politica?
+ *
+ * Sem politica no servico E sem a linha, nao ha o que apontar nem o que avisar — avisar
+ * ai seria ruido que ensina a ignorar aviso. Mas com a linha escrita e a politica vazia o
+ * import esta pendurado de verdade, e esse e o silencio que a memoria
+ * `import-do-claude-md-falha-calado` manda quebrar.
+ */
+export declare function confereOPonteiro(raiz: string, temPolitica: boolean): Promise<Ponteiro>;
+export declare function sync(raiz: string): Promise<Resultado>;
+export {};

package/dist/sync.js

@@ -1,4 +1,5 @@
 import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { pede } from "./api.js";
 import { dirname, join } from "node:path";
 import { gravaManifesto, hashDe, leConfigDoRepo, leManifesto, leToken, } from "./config.js";
 import { LINHA_DE_IMPORT, materializa } from "./materializa.js";
@@ -31,7 +32,7 @@ export async function confereDisco(raiz, arquivos) {
 }
 async function buscaBrain(config, token, etag) {
     const url = `${config.api}/api/v1/artefatos?tenant=${encodeURIComponent(config.tenant)}&projeto=${encodeURIComponent(config.projeto)}`;
-    const resposta = await fetch(url, {
+    const resposta = await pede(url, {
         headers: {
             Authorization: `Bearer ${token}`,
             ...(etag ? { "If-None-Match": etag } : {}),

package/package.json

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