dd-harness 0.20.0 → 0.22.0

package/dist/cinto.d.ts

@@ -30,6 +30,21 @@ export type CacheDeAncoras = {
     gravado_em: string;
     memorias: Pick<Memoria, "pasta" | "slug" | "titulo" | "resumo" | "status" | "ancoras">[];
 };
+/**
+ * Acrescenta UMA memoria ao cache, sem esperar a proxima sessao.
+ *
+ * Existe por um furo medido na rodada 006: o cache so era escrito pelo `SessionStart`, e
+ * memoria gravada no meio da sessao ficava invisivel ao cinto ate a sessao seguinte —
+ * justo no fluxo mais natural, que e gravar a memoria e ser avisado minutos depois se
+ * alguem tentar desfazer o que ela protege. A memoria nascia sem proteger nada.
+ *
+ * Escreve so o que ja esta na mao de quem gravou: sem rede, porque nao ha payload novo a
+ * buscar, e uma requisicao a mais no caminho de escrita nao se justifica para atualizar
+ * um cache que a proxima sessao reconstroi inteiro de qualquer jeito.
+ *
+ * Idempotente pelo endereco: regravar a mesma memoria substitui a entrada, nunca duplica.
+ */
+export declare function acrescentaAoCache(raiz: string, memoria: Pick<Memoria, "pasta" | "slug" | "titulo" | "resumo" | "status" | "ancoras">): Promise<void>;
 /** Guarda as ancoras do Brain para o hook consultar sem rede. Falha em silencio: cache e otimizacao, nao contrato. */
 export declare function guardaCache(raiz: string, brain: Brain): Promise<void>;
 export declare function leCache(raiz: string): Promise<CacheDeAncoras | null>;

package/dist/cinto.js

@@ -25,6 +25,41 @@ import { memoriasNoConteudo } from "./diff.js";
 export function caminhoDoCache(raiz) {
     return join(raiz, ".claude", "dd-harness-ancoras.json");
 }
+/**
+ * Acrescenta UMA memoria ao cache, sem esperar a proxima sessao.
+ *
+ * Existe por um furo medido na rodada 006: o cache so era escrito pelo `SessionStart`, e
+ * memoria gravada no meio da sessao ficava invisivel ao cinto ate a sessao seguinte —
+ * justo no fluxo mais natural, que e gravar a memoria e ser avisado minutos depois se
+ * alguem tentar desfazer o que ela protege. A memoria nascia sem proteger nada.
+ *
+ * Escreve so o que ja esta na mao de quem gravou: sem rede, porque nao ha payload novo a
+ * buscar, e uma requisicao a mais no caminho de escrita nao se justifica para atualizar
+ * um cache que a proxima sessao reconstroi inteiro de qualquer jeito.
+ *
+ * Idempotente pelo endereco: regravar a mesma memoria substitui a entrada, nunca duplica.
+ */
+export async function acrescentaAoCache(raiz, memoria) {
+    if (memoria.ancoras.length === 0)
+        return;
+    const atual = (await leCache(raiz)) ?? { gravado_em: "", memorias: [] };
+    const endereco = `${memoria.pasta}/${memoria.slug}`;
+    const cache = {
+        gravado_em: new Date().toISOString(),
+        memorias: [
+            ...atual.memorias.filter((m) => `${m.pasta}/${m.slug}` !== endereco),
+            memoria,
+        ],
+    };
+    try {
+        const caminho = caminhoDoCache(raiz);
+        await mkdir(dirname(caminho), { recursive: true });
+        await writeFile(caminho, `${JSON.stringify(cache)}\n`, "utf8");
+    }
+    catch {
+        // Mesmo motivo do `guardaCache`: cache e otimizacao, nao contrato.
+    }
+}
 /** Guarda as ancoras do Brain para o hook consultar sem rede. Falha em silencio: cache e otimizacao, nao contrato. */
 export async function guardaCache(raiz, brain) {
     const cache = {

package/dist/gravar.js

@@ -1,6 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { recusaPorAcentuacao } from "./acentuacao.js";
 import { cabecalhos, credencial, pede, recusa } from "./api.js";
+import { acrescentaAoCache } from "./cinto.js";
 const OBRIGATORIOS = ["name", "titulo", "description", "pasta"];
 /**
  * Frontmatter simples: `chave: valor` por linha. Sem lib de YAML — nao ha aninhamento.
@@ -188,6 +189,18 @@ export async function grava(raiz, caminho) {
     if (!resposta.ok)
         await recusa(resposta);
     const { endereco } = (await resposta.json());
+    // O cinto passa a enxergar esta memoria AGORA, nao na proxima sessao. Sem isto, a
+    // memoria recem-gravada nao protegia nada ate a sessao seguinte — medido na rodada 006,
+    // e justamente no fluxo mais comum: gravar a decisao e, minutos depois, alguem tentar
+    // desfazer o que ela guarda.
+    await acrescentaAoCache(raiz, {
+        pasta: memoria.pasta,
+        slug: memoria.slug,
+        titulo: memoria.titulo,
+        resumo: memoria.resumo,
+        status: "ativa",
+        ancoras: memoria.ancoras.map((valor) => ({ tipo: "caminho", valor, sha: null })),
+    });
     return {
         endereco,
         ancoras: memoria.ancoras.length,

package/dist/index.js

@@ -180,6 +180,10 @@ async function comandoFase(argv) {
  * primeira conexao do Claude Code. Sem isto, a primeira instalacao acontecia so quando
  * o host tentava conectar ao servidor MCP, e o handshake tem timeout curto demais para
  * esperar o download: a sessao real via `CONNECTION_CLOSED` em vez de "instalando".
+ *
+ * Roda em TODO `start`, nao so no primeiro: e tambem o ponto em que o cache do npx e
+ * renovado para a versao mais recente. Um projeto ja configurado que roda `start` de novo
+ * sai dali com CLI e MCP frescos, sem ninguem precisar lembrar de atualizar nada.
  */
 function instalaMcp() {
     return new Promise((resolve) => {
@@ -187,7 +191,14 @@ function instalaMcp() {
         // segundos) e, se falhar, ve POR QUE — em vez do "nao consegui" mudo que nao dava
         // pista nenhuma para diagnosticar. O DEP0190 que isto dispara e suprimido no topo
         // do arquivo (`process.removeAllListeners("warning")`).
-        const p = spawn("npx", ["-y", "dd-harness-mcp", "--help"], {
+        //
+        // `@latest` EXPLICITO, e nao `dd-harness-mcp` pelado: sem a tag, o npx serve a copia
+        // que ja estiver no cache dele e nem consulta o registro. Medido na rodada 006 — a
+        // cobaia rodou uma sessao inteira contra um MCP defasado sem nada denunciar. O
+        // `.mcp.json` continua declarando o pacote SEM versao, de proposito: o que precisa
+        // estar fresco e o cache, e fixar versao no arquivo obrigaria a reescrever config em
+        // todo repositorio a cada publicacao.
+        const p = spawn("npx", ["-y", "dd-harness-mcp@latest", "--help"], {
             shell: process.platform === "win32",
             stdio: "inherit",
         });
@@ -221,6 +232,32 @@ async function versaoDesatualizada() {
         return null;
     }
 }
+/**
+ * Instala a versao mais nova do CLI globalmente, de dentro do proprio wizard.
+ *
+ * Ate aqui o `start` so AVISAVA e mandava o usuario rodar `npm i -g` e recomecar — e
+ * "comece de novo" no meio de um wizard e o tipo de instrucao que ninguem segue. A
+ * rodada 006 mostrou o custo: a sessao inteira rodou contra um CLI defasado, com o
+ * relatorio registrando "ja instalado, nao atualizado" como se fosse normal.
+ *
+ * O binario EM EXECUCAO continua sendo o antigo ate este processo terminar — nao ha como
+ * trocar codigo de baixo de si mesmo. Isso e seguro aqui porque o que resta do wizard so
+ * escreve configuracao (JSON e markdown), nada que dependa de correcao nova; e do
+ * proximo comando em diante tudo ja e a versao nova.
+ *
+ * Nunca lanca: falhar em atualizar nao pode travar o `start`. Sem permissao para escrever
+ * no diretorio global (o caso mais comum), o wizard segue e o aviso continua valendo.
+ */
+function atualizaCli(ultima) {
+    return new Promise((resolve) => {
+        const p = spawn("npm", ["install", "-g", `dd-harness@${ultima}`], {
+            shell: process.platform === "win32",
+            stdio: "inherit",
+        });
+        p.on("exit", (code) => resolve(code === 0));
+        p.on("error", () => resolve(false));
+    });
+}
 /**
  * Tenta abrir o navegador padrao. Nunca lanca — falhar em abrir nao pode travar o
  * wizard, so degrada para "aqui esta a URL, abra voce mesmo".
@@ -271,9 +308,14 @@ async function comandoStart() {
     // pre-instalacao do MCP, passo 5.5 abaixo, numa versao anterior a ela existir).
     const desatualizado = await versaoDesatualizada();
     if (desatualizado) {
-        console.log(`AVISO: você está na versão ${desatualizado.atual}, e a mais recente é ` +
-            `${desatualizado.ultima}. Rode \`npm install -g dd-harness@latest\` e comece de ` +
-            "novo — start segue mesmo assim, mas pode faltar correção.\n");
+        console.log(`Atualizando o dd-harness: ${desatualizado.atual} → ${desatualizado.ultima}...`);
+        const atualizou = await atualizaCli(desatualizado.ultima);
+        console.log(atualizou
+            ? `Pronto — ${desatualizado.ultima} instalada. O wizard segue na ${desatualizado.atual} ` +
+                "(o binário em execução não troca sozinho); do próximo comando em diante, a nova.\n"
+            : `Não consegui atualizar (sem permissão de escrita global?). Você está na ` +
+                `${desatualizado.atual} e a mais recente é ${desatualizado.ultima} — rode ` +
+                "`npm install -g dd-harness@latest` quando puder. O start segue assim mesmo.\n");
     }
     // 1. Credencial. Sem ela nada do resto e possivel — nem listar tenant.
     // O estado aparece SEMPRE, mesmo quando ja existe credencial: antes o passo era
@@ -366,7 +408,8 @@ async function comandoStart() {
         }[mcp.estado]);
     }
     if (mcp.ok) {
-        console.log("\nInstalando o servidor dd-harness-mcp (primeira vez pode demorar um pouco)...");
+        console.log("\nInstalando a versão mais recente do servidor dd-harness-mcp " +
+            "(a primeira vez pode demorar um pouco)...");
         const { ok: instalou, erro: erroInstalacao } = await instalaMcp();
         console.log(instalou
             ? "dd-harness-mcp instalado — a próxima sessão do Claude Code conecta na hora."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-harness",
-  "version": "0.20.0",
+  "version": "0.22.0",
   "type": "module",
   "description": "Cliente do dd-harness: politica no inicio da sessao, e memoria por busca — nada em disco. Sem dependencia: fetch, crypto e fs sao do Node.",
   "license": "UNLICENSED",