dd-harness 0.39.0 → 0.40.1

package/dist/atualizar.d.ts

@@ -21,6 +21,8 @@ export type Item = {
  * maquina, nao por projeto).
  */
 export declare function diagnosticaAtualizacao(raiz: string, versaoInstalada: string, versaoPublicada: string | null): Promise<Item[]>;
+/** Reescreve em disco os ponteiros das skills que o serviço tem. */
+export declare function reescrevePonteiros(raiz: string): Promise<string>;
 /**
  * Incorpora ao projeto as skills iniciais escolhidas pelo usuario.
  *

package/dist/atualizar.js

@@ -140,7 +140,7 @@ export async function diagnosticaAtualizacao(raiz, versaoInstalada, versaoPublic
     return itens;
 }
 /** Reescreve em disco os ponteiros das skills que o serviço tem. */
-async function reescrevePonteiros(raiz) {
+export 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"]);

package/dist/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { diagnostico } from "./diagnostico.js";
-import { aplicaAtualizacao, diagnosticaAtualizacao, versaoInstalada, versaoPublicada } from "./atualizar.js";
+import { aplicaAtualizacao, diagnosticaAtualizacao, reescrevePonteiros, versaoInstalada, versaoPublicada } from "./atualizar.js";
 import { instalaHosts, selecionaHosts } from "./hosts.js";
 import { achaRaiz } from "./config.js";
 import { abreSessao, guardaSessao, saidaDaGuarda, saidaDoBoot } from "./sessao.js";
@@ -27,7 +27,7 @@ import { pergunta, escolha, fechaPerguntas } from "./pergunta.js";
 import { buscaPolitica } from "./politica.js";
 import { avisoDeOrdem, blocoDeSessao, criaFase, editaFase, formataChangelog, formataRoadmap, leFases, } from "./roadmap.js";
 import { decideDoHook, guardaCache } from "./cinto.js";
-import { escrevePonteirosDeSkills, leSkill, leSkills, semeiaSkills } from "./skill.js";
+import { criaSkill, editaSkill, escrevePonteirosDeSkills, leSkill, leSkills, semeiaSkills } from "./skill.js";
 import { SKILLS_INICIAIS } from "./skills-iniciais.js";
 import { busca } from "./buscar.js";
 import { apaga, arquiva, edita, le, promove } from "./curar.js";
@@ -80,7 +80,7 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
                                      projeto do espaço, inclusive os futuros
   dd-harness despromover <pasta>/<slug>
                                      traz de volta ao alcance dos vínculos
-  dd-harness apagar <pasta>/<slug> [--confirmar "<frase devolvida>"]
+  dd-harness apagar <pasta>/<slug> [--confirmar "<frase devolvida>"]
                                      apaga de vez, em cascata — sem desfazer.
                                      Para tirar de circulação guardando o
                                      conteúdo, use "arquivar"
@@ -101,6 +101,11 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
   dd-harness skills                 as skills deste projeto e quando cada uma serve
   dd-harness skill <nome>           o procedimento de uma delas (o mesmo que o
                                      agente recebe ao invocá-la)
+  dd-harness skill criar <nome> --descricao "<quando invocar>" [--conteudo <arquivo.md>]
+                     [--so-por-comando true|false]
+  dd-harness skill editar <nome> [--descricao "<d>"] [--conteudo <arquivo.md>]
+                     [--so-por-comando true|false]
+                                     grava no serviço e reescreve o ponteiro em disco
   dd-harness roadmap                as fases abertas: a atual inteira, as próximas
                                      por título (opcional — projeto sem fase não tem)
   dd-harness changelog [--versao <v>]
@@ -140,11 +145,9 @@ function argumento(argv, nome) {
 const API_PADRAO = "https://dd-harness.vercel.app";
 // --- roadmap e changelog ---
 /**
- * `skills` e `skill <slug>` — so LEITURA.
- *
- * Criar e editar ficam na interface de proposito: escrever procedimento e trabalho de
- * texto longo, e um editor de verdade e melhor que um flag de linha de comando. O que o
- * terminal precisa e ver o que existe e conferir um procedimento sem trocar de janela.
+ * `skills` e `skill <slug>` — leitura. Criar e editar sao `skill criar|editar`, com o
+ * procedimento vindo de um .md (`--conteudo`), como em `fase` e `gravar`: sem isso a skill
+ * `escrever-skill` redigia o texto e nao tinha como grava-lo fora da interface.
  */
 async function comandoSkills() {
     const skills = await leSkills(process.cwd());
@@ -160,10 +163,44 @@ async function comandoSkills() {
     }
     console.log(`${skills.length} skill(s). \`dd-harness skill <nome>\` mostra o procedimento.`);
 }
+/** `--so-por-comando true|false`: flag solta seria so "ligar", e desligar tambem e edicao. */
+function soPorComandoDoArgv(argv) {
+    const v = argumento(argv, "so-por-comando");
+    if (v === undefined)
+        return undefined;
+    if (v !== "true" && v !== "false")
+        throw new Error("--so-por-comando: use true ou false.");
+    return v === "true";
+}
+/**
+ * `skill criar` e `skill editar`. O ponteiro em disco e reescrito em seguida: descricao e
+ * "so por comando" moram no frontmatter dele, e o host so le o disco.
+ */
+async function comandoSkillEscrita(acao, argv) {
+    const [slug, ...opcoes] = argv;
+    if (!slug || slug.startsWith("--"))
+        throw new Error(`skill ${acao} exige o nome da skill.`);
+    const campos = {
+        descricao: argumento(opcoes, "descricao"),
+        conteudo: await conteudoDoArgv(opcoes),
+        so_por_comando: soPorComandoDoArgv(opcoes),
+    };
+    if (acao === "criar") {
+        if (!campos.descricao)
+            throw new Error('skill criar exige --descricao "<quando invocar>".');
+        await criaSkill(process.cwd(), { ...campos, slug, descricao: campos.descricao, conteudo: campos.conteudo ?? "" });
+    }
+    else {
+        await editaSkill(process.cwd(), slug, campos);
+    }
+    console.log(`Skill ${slug} ${acao === "criar" ? "criada" : "atualizada"}; ${await reescrevePonteiros(process.cwd())}.`);
+}
 async function comandoSkill(argv) {
     const slug = argv[0];
+    if (slug === "criar" || slug === "editar")
+        return comandoSkillEscrita(slug, argv.slice(1));
     if (!slug || slug.startsWith("-")) {
-        throw new Error("uso: dd-harness skill <nome>");
+        throw new Error("uso: dd-harness skill <nome>  |  dd-harness skill criar|editar <nome> [...]");
     }
     const s = await leSkill(process.cwd(), slug);
     console.log(`# ${s.slug}

package/dist/sessao.js

@@ -1,11 +1,11 @@
 import { createHash, randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { join, resolve } from "node:path";
 import { credencial } from "./api.js";
 import { achaRaiz } from "./config.js";
 import { decideDoHook, guardaCache, leCache } from "./cinto.js";
 import { edicoesDaChamada, normalizaEntrada } from "./edicoes.js";
-import { estadoDoRepo, escreveAtomico, revisaoDoContexto } from "./estado-local.js";
+import { diretorioDoUsuario, estadoDoRepo, escreveAtomico, revisaoDoContexto } from "./estado-local.js";
 import { buscaPolitica } from "./politica.js";
 import { blocoDeSessao } from "./roadmap.js";
 import { leSkills, escrevePonteirosDeSkills } from "./skill.js";
@@ -14,21 +14,38 @@ import { subiuOWorker } from "./worker.js";
 const PRAZO = 4 * 60 * 60 * 1000;
 const hash = (s) => createHash("sha256").update(s).digest("hex");
 const arquivo = (raiz, sessao, host) => join(estadoDoRepo(raiz), `sessao-${hash(host + sessao)}.json`);
+const arquivoDaRaiz = (sessao, host) => join(diretorioDoUsuario(), "sessoes", `${hash(host + sessao)}.json`);
+async function raizDaSessao(sessao, host) {
+    try {
+        const lido = JSON.parse(await readFile(arquivoDaRaiz(sessao, host), "utf8"));
+        return typeof lido.raiz === "string" ? lido.raiz : null;
+    }
+    catch {
+        return null;
+    }
+}
+const mesmaRaiz = (a, b) => process.platform === "win32" ? resolve(a).toLowerCase() === resolve(b).toLowerCase() : resolve(a) === resolve(b);
 async function identidade(raiz) {
     const c = await credencial(raiz);
     return hash(JSON.stringify(c)); // inclui token sem expô-lo em disco/log.
 }
-async function estadoAtual(raiz, sessao, host) {
+async function estadoConhecido(raiz, sessao, host) {
     try {
         const e = JSON.parse(await readFile(arquivo(raiz, sessao, host), "utf8"));
-        if (e.estado === "ok" && e.revisao !== await revisaoDoContexto(raiz))
-            return null;
-        return e.identidade === await identidade(raiz) && Date.now() >= e.em && Date.now() - e.em < PRAZO ? e : null;
+        return e.identidade === await identidade(raiz) && Date.now() >= e.em ? e : null;
     }
     catch {
         return null;
     }
 }
+async function estadoAtual(raiz, sessao, host) {
+    const e = await estadoConhecido(raiz, sessao, host);
+    if (!e || Date.now() - e.em >= PRAZO)
+        return null;
+    if (e.estado === "ok" && e.revisao !== await revisaoDoContexto(raiz))
+        return null;
+    return e;
+}
 export function saidaDoBoot(host, contexto, ok) {
     return host === "antigravity"
         ? { injectSteps: contexto ? [{ ephemeralMessage: contexto }] : [] }
@@ -39,7 +56,9 @@ export async function abreSessao(host, entrada) {
     const c = normalizaEntrada(host, entrada);
     if (!c.sessao)
         throw new Error("hook sem identificador de sessão: não é possível validar o boot");
-    const raiz = await achaRaiz(c.raiz);
+    const raiz = await achaRaiz(c.raiz).catch(() => raizDaSessao(c.sessao, host));
+    if (!raiz)
+        throw new Error("dd-harness: projeto não encontrado. Abra a sessão a partir de um projeto configurado.");
     const anterior = await estadoAtual(raiz, c.sessao, host);
     // A mensagem do Antigravity é efêmera: não presumir que sobreviva à próxima inferência.
     const inicio = host !== "antigravity" || Number(entrada.invocationNum) === 0 || anterior?.estado !== "ok";
@@ -85,6 +104,7 @@ export async function abreSessao(host, entrada) {
         contexto = `PARE: não foi possível carregar a política e o briefing. ${r.motivo}. Corrija a conexão/configuração e reabra a sessão.`;
     await escreveAtomico(arquivo(raiz, c.sessao, host), JSON.stringify({ identidade: id,
         revisao, ciclo, estado: r.estado, em: Date.now() }));
+    await escreveAtomico(arquivoDaRaiz(c.sessao, host), JSON.stringify({ raiz }));
     return saidaDoBoot(host, contexto, r.estado !== "inalcancavel");
 }
 export function saidaDaGuarda(host, motivo, contexto) {
@@ -113,44 +133,64 @@ const LEITURA_MCP = /^mcp__dd[-_]harness__(ler_artefato|ler_roadmap|ler_changelo
 const ONBOARDING = /^(ToolSearch|mcp__dd[-_]harness__(escrever_artefato|criar_pasta|criar_projeto))$/;
 export async function guardaSessao(host, entrada) {
     const c = normalizaEntrada(host, entrada);
-    const raiz = await achaRaiz(c.raiz);
-    const e = c.sessao ? await estadoAtual(raiz, c.sessao, host) : null;
+    const vinculada = c.sessao ? await raizDaSessao(c.sessao, host) : null;
+    const atual = await achaRaiz(c.raiz).catch(() => null);
+    if (vinculada && atual && !mesmaRaiz(vinculada, atual)) {
+        return saidaDaGuarda(host, "dd-harness: esta sessão pertence a outro projeto. Abra uma sessão neste projeto para carregar sua política e seu briefing.");
+    }
+    const raiz = atual ?? vinculada;
+    if (!raiz) {
+        if (LEITURA.test(c.ferramenta) || LEITURA_MCP.test(c.ferramenta))
+            return saidaDaGuarda(host);
+        return saidaDaGuarda(host, "dd-harness: esta sessão não tem projeto associado. Volte ao projeto configurado e abra uma sessão nele; não rode `dd-harness start` na pasta de rascunho.");
+    }
+    const edicoes = edicoesDaChamada(c);
+    for (const edicao of edicoes) {
+        const projetoDoArquivo = await achaRaiz(edicao.arquivo).catch(() => null);
+        if (projetoDoArquivo && !mesmaRaiz(projetoDoArquivo, raiz)) {
+            return saidaDaGuarda(host, "dd-harness: o arquivo pertence a outro projeto. Abra uma sessão nesse projeto antes de editá-lo.");
+        }
+    }
+    let e = c.sessao ? await estadoAtual(raiz, c.sessao, host) : null;
+    let contextoAtualizado = "";
     if (e?.estado !== "ok") {
         if (LEITURA.test(c.ferramenta) || LEITURA_MCP.test(c.ferramenta))
             return saidaDaGuarda(host);
-        // O dia zero de um projeto novo trava num ciclo: gravar o briefing exige a guarda
-        // liberada, e a guarda so libera com briefing gravado. `estadoAtual` devolve `null`
-        // tanto para "projeto novo" quanto para "sessao expirada", entao o estado local nao
-        // distingue os dois — quem sabe e o SERVICO. Se ele diz que nao ha politica, este
-        // projeto ainda esta em onboarding e as ferramentas de escreve-lo passam.
+        const anterior = c.sessao ? await estadoConhecido(raiz, c.sessao, host) : null;
+        // Projeto novo so pode completar o briefing se as ferramentas que o escrevem passarem.
+        // Quem distingue onboarding de contexto indisponivel e o servico.
         //
         // Nao e afrouxamento: o que passa aqui e so o que CONSTROI o contexto obrigatorio, e
         // so enquanto ele nao existe. Na primeira politica gravada, este caminho fecha sozinho.
+        const revisao = await revisaoDoContexto(raiz);
         const r = await buscaPolitica(raiz).catch(() => null);
         if (ONBOARDING.test(c.ferramenta) && r?.estado === "sem-politica")
             return saidaDaGuarda(host);
-        // O briefing acabou de ser gravado NESTA sessao: o servico ja tem os dois, mas o boot
-        // desta sessao rodou quando nao havia nada, e o estado local ficou velho. O agente sai
-        // do onboarding direto para um segundo bloqueio, sem nada indicando o que fazer —
-        // medido no dd-playwright, onde ele concluiu sozinho que precisava reiniciar e pediu
-        // ao usuario.
-        //
-        // Continua NEGANDO, e de proposito: e o SessionStart que entrega politica e briefing ao
-        // modelo, e liberar aqui daria trabalho sem o contexto que a guarda existe para
-        // garantir. O que muda e a mensagem — quem le passa a saber que o projeto esta pronto e
-        // que falta so reabrir, em vez de procurar o que ainda estaria faltando.
-        if (r?.estado === "ok") {
+        if (r?.estado === "ok" && (anterior?.estado === "ok" || anterior?.estado === "sem-politica")) {
+            if (revisao !== await revisaoDoContexto(raiz)) {
+                return saidaDaGuarda(host, "dd-harness: o contexto mudou durante a atualização. Repita a chamada para carregar a versão atual.");
+            }
+            await guardaCache(raiz, { memorias: r.memorias ?? [] });
+            e = { identidade: anterior.identidade, revisao, ciclo: randomUUID(), estado: "ok", em: Date.now() };
+            contextoAtualizado = "dd-harness: política e briefing atualizados nesta sessão. Este contexto substitui as versões anteriores:\n\n" +
+                r.conteudo + blocoDeSessao(r.roadmap);
+        }
+        else if (r?.estado === "ok") {
             return saidaDaGuarda(host, "dd-harness: política e briefing JÁ EXISTEM no serviço, mas o boot " +
-                "desta sessão rodou antes de eles existirem — por isso o contexto não chegou ao modelo. " +
+                "desta sessão não foi validado — por isso o contexto não chegou ao modelo. " +
                 "Nada falta gravar: **reabra a sessão** para o boot carregá-los. " +
                 "Enquanto isso, leitura (Read/Glob/Grep) e as ferramentas de leitura do dd-harness continuam liberadas.");
         }
-        return saidaDaGuarda(host, "dd-harness: política e briefing não foram carregados nesta sessão/projeto. " +
-            "Se este projeto é novo, conduza o briefing e grave os dois com `escrever_artefato`; " +
-            "se não, reabra a sessão para o boot rodar.");
+        else if (r?.estado === "inalcancavel") {
+            return saidaDaGuarda(host, `dd-harness: não foi possível atualizar política e briefing: ${r.motivo}. Confira a conexão e repita a chamada.`);
+        }
+        else {
+            return saidaDaGuarda(host, "dd-harness: política e briefing não foram carregados nesta sessão/projeto. " +
+                "Se este projeto é novo, conduza o briefing e grave os dois com `escrever_artefato`; " +
+                "se não, confira a conexão e reabra a sessão para o boot rodar.");
+        }
     }
-    const edicoes = edicoesDaChamada(c);
-    const avisos = [];
+    const avisos = contextoAtualizado ? [contextoAtualizado] : [];
     if (edicoes.length && !await leCache(raiz)) {
         const r = await buscaPolitica(raiz);
         if (r.estado !== "ok") {
@@ -167,5 +207,11 @@ export async function guardaSessao(host, entrada) {
         if (r.hookSpecificOutput.additionalContext)
             avisos.push(r.hookSpecificOutput.additionalContext);
     }
+    if (contextoAtualizado) {
+        if (e.revisao !== await revisaoDoContexto(raiz)) {
+            return saidaDaGuarda(host, "dd-harness: o contexto mudou durante a atualização. Repita a chamada para carregar a versão atual.");
+        }
+        await escreveAtomico(arquivo(raiz, c.sessao, host), JSON.stringify(e));
+    }
     return saidaDaGuarda(host, undefined, avisos.join("\n\n"));
 }

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.