dd-harness 0.20.0 → 0.21.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/package.json

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