dd-harness 0.24.0 → 0.26.0

package/dist/brain.d.ts

@@ -18,6 +18,11 @@ export type Memoria = {
     resumo: string;
     corpo: string;
     status: "ativa" | "historico";
+    /**
+     * `global` = vale para todo projeto do tenant, inclusive os que ainda nao existem.
+     * Ausente em payload antigo, e ai a memoria e de projeto — que era o unico escopo.
+     */
+    escopo?: "projeto" | "global";
     dano: string;
     invisibilidade: string;
     externalidade: string;

package/dist/cinto.d.ts

@@ -28,7 +28,7 @@ export declare function caminhoDoCache(raiz: string): string;
  */
 export type CacheDeAncoras = {
     gravado_em: string;
-    memorias: Pick<Memoria, "pasta" | "slug" | "titulo" | "resumo" | "status" | "ancoras">[];
+    memorias: Pick<Memoria, "pasta" | "slug" | "titulo" | "resumo" | "status" | "ancoras" | "escopo">[];
 };
 /**
  * Acrescenta UMA memoria ao cache, sem esperar a proxima sessao.
@@ -44,7 +44,7 @@ export type CacheDeAncoras = {
  *
  * 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>;
+export declare function acrescentaAoCache(raiz: string, memoria: Pick<Memoria, "pasta" | "slug" | "titulo" | "resumo" | "status" | "ancoras" | "escopo">): 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>;
@@ -78,7 +78,7 @@ export declare function alerta(tocadas: {
     pasta: string;
     memoria: string;
     ancora: string;
-}[], resumos: Map<string, string>): string;
+}[], resumos: Map<string, string>, globais?: Set<string>): string;
 /**
  * O hook inteiro: le a entrada, cruza, devolve o JSON que o Claude Code espera.
  *

package/dist/cinto.js

@@ -66,13 +66,14 @@ export async function guardaCache(raiz, brain) {
         gravado_em: new Date().toISOString(),
         memorias: brain.memorias
             .filter((m) => m.status === "ativa" && m.ancoras.length > 0)
-            .map(({ pasta, slug, titulo, resumo, status, ancoras }) => ({
+            .map(({ pasta, slug, titulo, resumo, status, ancoras, escopo }) => ({
             pasta,
             slug,
             titulo,
             resumo,
             status,
             ancoras,
+            escopo,
         })),
     };
     try {
@@ -143,7 +144,7 @@ export function caminhoRelativo(raiz, arquivo) {
  * Vazio e o caso comum e tem que sair barato: a maioria das edicoes nao toca ancora
  * alguma, e o silencio ai nao e falta de aviso, e a ausencia de motivo para avisar.
  */
-export function alerta(tocadas, resumos) {
+export function alerta(tocadas, resumos, globais = new Set()) {
     if (tocadas.length === 0)
         return "";
     const linhas = [
@@ -152,7 +153,11 @@ export function alerta(tocadas, resumos) {
     ];
     for (const t of tocadas) {
         const endereco = `${t.pasta}/${t.memoria}`;
-        linhas.push(`## ${t.titulo}`, `\`${endereco}\` — âncora: \`${t.ancora}\``, "");
+        // Marcar a global muda o peso do que se le: a licao nao fala DESTE projeto, fala de
+        // todos. Sem a marca, o agente a avalia como decisao local e pode concluir que "aqui
+        // e diferente" — que e exatamente o raciocinio que a promocao existiu para vencer.
+        const marca = globais.has(endereco) ? " · MEMÓRIA GLOBAL" : "";
+        linhas.push(`## ${t.titulo}${marca}`, `\`${endereco}\` — âncora: \`${t.ancora}\``, "");
         const resumo = resumos.get(endereco);
         if (resumo)
             linhas.push(resumo, "");
@@ -203,11 +208,12 @@ export async function decideDoHook(entrada) {
     if (novas.length === 0)
         return permitir;
     const resumos = new Map(cache.memorias.map((m) => [`${m.pasta}/${m.slug}`, m.resumo]));
+    const globais = new Set(cache.memorias.filter((m) => m.escopo === "global").map((m) => `${m.pasta}/${m.slug}`));
     return JSON.stringify({
         hookSpecificOutput: {
             hookEventName: "PreToolUse",
             permissionDecision: "allow",
-            additionalContext: alerta(novas, resumos),
+            additionalContext: alerta(novas, resumos, globais),
         },
     });
 }

package/dist/curar.d.ts

@@ -54,3 +54,30 @@ export declare function arquiva(raiz: string, endereco: string, opcoes: Arquivam
     endereco: string;
     motivo: string;
 }>;
+/**
+ * Promove a memoria a global — ou a traz de volta ao projeto de origem.
+ *
+ * Global vale para TODO projeto do espaco, inclusive os que ainda nao existem. E o degrau
+ * acima de `memory_projects`, que lista projetos nomeados: aqui o alcance deixa de ser
+ * uma lista e vira uma propriedade.
+ */
+export declare function promove(raiz: string, endereco: string, global: boolean): Promise<{
+    escopo: string;
+    global: boolean;
+    tenant: string | null;
+}>;
+/**
+ * Apaga de verdade, em cascata — ancoras, deriva medida, vinculos, tudo.
+ *
+ * Diferente de `arquiva`, que e o caminho normal: arquivar guarda o conteudo porque o que
+ * a memoria dizia pode voltar a importar. Isto e para o que nunca deveria ter existido.
+ *
+ * Sem `confirmacao`, o servidor RECUSA e devolve o que a cascata levaria junto — e so
+ * entao se repete a chamada com o nome do espaco. Duas etapas de proposito: DELETE nao
+ * tem desfazer, e a cascata e invisivel de fora.
+ */
+export declare function apaga(raiz: string, endereco: string, confirmacao?: string): Promise<{
+    apagou: boolean;
+    detalhe: string;
+    confirmacaoEsperada?: string;
+}>;

package/dist/curar.js

@@ -92,3 +92,52 @@ export async function arquiva(raiz, endereco, opcoes) {
     const lido = (await resposta.json());
     return lido;
 }
+/**
+ * Promove a memoria a global — ou a traz de volta ao projeto de origem.
+ *
+ * Global vale para TODO projeto do espaco, inclusive os que ainda nao existem. E o degrau
+ * acima de `memory_projects`, que lista projetos nomeados: aqui o alcance deixa de ser
+ * uma lista e vira uma propriedade.
+ */
+export async function promove(raiz, endereco, global) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}/escopo`, {
+        method: "PUT",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({ tenant: config.tenant, projeto: config.projeto, global }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}
+/**
+ * Apaga de verdade, em cascata — ancoras, deriva medida, vinculos, tudo.
+ *
+ * Diferente de `arquiva`, que e o caminho normal: arquivar guarda o conteudo porque o que
+ * a memoria dizia pode voltar a importar. Isto e para o que nunca deveria ter existido.
+ *
+ * Sem `confirmacao`, o servidor RECUSA e devolve o que a cascata levaria junto — e so
+ * entao se repete a chamada com o nome do espaco. Duas etapas de proposito: DELETE nao
+ * tem desfazer, e a cascata e invisivel de fora.
+ */
+export async function apaga(raiz, endereco, confirmacao) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/memorias/${endereco}/apagar`, {
+        method: "POST",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            ...(confirmacao ? { confirmacao } : {}),
+        }),
+    });
+    // 409 aqui nao e falha: e "ainda nao" — falta confirmar, ou ha uma arquivada apontando
+    // para esta. O texto do servidor e a resposta, entao ele passa adiante em vez de virar
+    // excecao com mensagem generica.
+    if (resposta.status === 409) {
+        const lido = (await resposta.json());
+        return { apagou: false, detalhe: lido.erro, confirmacaoEsperada: lido.confirmacao_esperada };
+    }
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}

package/dist/index.js

@@ -22,7 +22,7 @@ import { buscaPolitica } from "./politica.js";
 import { avisoDeOrdem, blocoDeSessao, criaFase, editaFase, formataChangelog, formataRoadmap, leFases, } from "./roadmap.js";
 import { decideDoHook, guardaCache } from "./cinto.js";
 import { busca } from "./buscar.js";
-import { arquiva, edita, le } from "./curar.js";
+import { apaga, arquiva, edita, le, promove } from "./curar.js";
 import { criaPasta } from "./pasta.js";
 import { criaProjeto, listaTenants } from "./projeto.js";
 import { reancora } from "./reancorar.js";
@@ -52,6 +52,15 @@ const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
   dd-harness arquivar <pasta>/<slug> --motivo <obsoleta|incorreta|fora_dos_filtros>
                      [--substituida-por <pasta>/<slug>]
                                      tira de circulação sem apagar
+  dd-harness promover <pasta>/<slug>
+                                     torna a memória global: vale para TODO
+                                     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 <espaço>]
+                                     apaga de vez, em cascata — sem desfazer.
+                                     Para tirar de circulação guardando o
+                                     conteúdo, use "arquivar"
   dd-harness buscar "<pergunta>"     acha memória por relevância, não por arquivo
   dd-harness ler <pasta>/<slug>      imprime a memória inteira, no formato de gravar
   dd-harness reancorar <pasta>/<slug> --de "<alvo>" --para "<alvo>"
@@ -520,6 +529,49 @@ async function comandoEditar(argv) {
     console.log(`  ${r.ancoras} âncora(s).`);
 }
 const MOTIVOS = ["obsoleta", "incorreta", "fora_dos_filtros"];
+/**
+ * `promover` / `despromover` — o alcance da memoria.
+ *
+ * Global vale para TODO projeto do espaco, inclusive os que ainda nao existem. Nao e o
+ * mesmo que `projetos:` no frontmatter, que lista projetos nomeados: la o alcance e uma
+ * lista, aqui e uma propriedade.
+ */
+async function comandoPromover(argv, global) {
+    const endereco = argv[0];
+    const verbo = global ? "promover" : "despromover";
+    if (!endereco || endereco.startsWith("-") || !endereco.includes("/")) {
+        throw new Error(`uso: dd-harness ${verbo} <pasta>/<slug>`);
+    }
+    const r = await promove(process.cwd(), endereco, global);
+    console.log(global
+        ? `${endereco} agora é GLOBAL — vale para todo projeto de ${r.tenant}, inclusive os que ainda não existem.`
+        : `${endereco} voltou a valer só para os projetos a que está vinculada.`);
+}
+/**
+ * `apagar` — o unico caminho que destroi.
+ *
+ * Duas etapas, e a segunda pede o nome do espaco digitado. Nao e cerimonia: a cascata leva
+ * ancoras e toda a deriva medida delas, e nao ha desfazer. Arquivar continua sendo o
+ * caminho normal — isto e para o que nunca deveria ter existido.
+ */
+async function comandoApagar(argv) {
+    const endereco = argv[0];
+    if (!endereco || endereco.startsWith("-") || !endereco.includes("/")) {
+        throw new Error("uso: dd-harness apagar <pasta>/<slug> [--confirmar <espaço>]");
+    }
+    const r = await apaga(process.cwd(), endereco, argumento(argv, "confirmar"));
+    if (!r.apagou) {
+        console.log(r.detalhe);
+        if (r.confirmacaoEsperada) {
+            console.log(`
+  dd-harness apagar ${endereco} --confirmar ${r.confirmacaoEsperada}`);
+        }
+        // Sem exit diferente de zero: recusar por falta de confirmacao nao e falha, e o
+        // caminho normal da primeira chamada.
+        return;
+    }
+    console.log(`${endereco} apagada — ${r.detalhe}`);
+}
 async function comandoArquivar(argv) {
     const endereco = argv[0];
     const motivo = argumento(argv, "motivo");
@@ -995,6 +1047,12 @@ async function principal() {
             return comandoEditar(resto);
         case "arquivar":
             return comandoArquivar(resto);
+        case "promover":
+            return comandoPromover(resto, true);
+        case "despromover":
+            return comandoPromover(resto, false);
+        case "apagar":
+            return comandoApagar(resto);
         case "ler":
             return comandoLer(resto);
         case "buscar":

package/dist/init.d.ts

@@ -24,16 +24,23 @@ export type ResultadoDoInit = {
  */
 export declare const SUGESTAO_MCP = "{\n  \"mcpServers\": {\n    \"dd-harness\": {\n      \"command\": \"npx\",\n      \"args\": [\"-y\", \"dd-harness-mcp\"]\n    }\n  }\n}";
 /**
- * O hook que carrega a politica no inicio de cada sessao.
+ * Os dois hooks do dd-harness, pelas duas razoes que nenhuma instrucao em markdown
+ * resolve.
  *
- * E a garantia de que nenhuma sessao abre sem protocolo — o papel que antes era do
- * arquivo materializado mais a linha de import. Vive num hook, e nao numa instrucao no
- * `CLAUDE.md`, porque instrucao o modelo pode pular: o import quebrado falhava em
- * silencio, e isso foi medido.
+ * `SessionStart` carrega a politica no inicio de cada sessao — a garantia de que nenhuma
+ * abre sem protocolo, papel que antes era do arquivo materializado mais a linha de
+ * import. Vive num hook, e nao numa instrucao no `CLAUDE.md`, porque instrucao o modelo
+ * pode pular: o import quebrado falhava em silencio, e isso foi medido.
+ *
+ * `PreToolUse` e o cinto: cruza o arquivo que esta sendo editado contra as ancoras e
+ * entrega a memoria ANTES da edicao. Existe porque o Brain era todo PULL, e PULL falha
+ * onde mais custa — o agente nao busca memoria quando *acha que sabe*. Os dois vao
+ * juntos aqui de proposito: quem monta o `settings.json` a mao pelo `init` sairia sem o
+ * cinto e sem nunca saber que ele existe.
  *
  * Sugerido e nao escrito, pelo mesmo motivo do `.mcp.json`.
  */
-export declare const SUGESTAO_HOOK = "{\n  \"hooks\": {\n    \"SessionStart\": [\n      {\n        \"hooks\": [\n          {\n            \"type\": \"command\",\n            \"command\": \"dd-harness politica --hook\",\n            \"statusMessage\": \"Carregando a pol\u00EDtica do dd-harness...\"\n          }\n        ]\n      }\n    ]\n  }\n}";
+export declare const SUGESTAO_HOOK = "{\n  \"hooks\": {\n    \"SessionStart\": [\n      {\n        \"hooks\": [\n          {\n            \"type\": \"command\",\n            \"command\": \"dd-harness politica --hook\",\n            \"statusMessage\": \"Carregando a pol\u00EDtica do dd-harness...\"\n          }\n        ]\n      }\n    ],\n    \"PreToolUse\": [\n      {\n        \"matcher\": \"Edit|Write|MultiEdit\",\n        \"hooks\": [\n          {\n            \"type\": \"command\",\n            \"command\": \"dd-harness cinto\"\n          }\n        ]\n      }\n    ]\n  }\n}";
 /**
  * O que escrever num `AGENTS.md`, para agente que NAO e o Claude Code.
  *

package/dist/init.js

@@ -17,12 +17,19 @@ export const SUGESTAO_MCP = `{
   }
 }`;
 /**
- * O hook que carrega a politica no inicio de cada sessao.
+ * Os dois hooks do dd-harness, pelas duas razoes que nenhuma instrucao em markdown
+ * resolve.
  *
- * E a garantia de que nenhuma sessao abre sem protocolo — o papel que antes era do
- * arquivo materializado mais a linha de import. Vive num hook, e nao numa instrucao no
- * `CLAUDE.md`, porque instrucao o modelo pode pular: o import quebrado falhava em
- * silencio, e isso foi medido.
+ * `SessionStart` carrega a politica no inicio de cada sessao — a garantia de que nenhuma
+ * abre sem protocolo, papel que antes era do arquivo materializado mais a linha de
+ * import. Vive num hook, e nao numa instrucao no `CLAUDE.md`, porque instrucao o modelo
+ * pode pular: o import quebrado falhava em silencio, e isso foi medido.
+ *
+ * `PreToolUse` e o cinto: cruza o arquivo que esta sendo editado contra as ancoras e
+ * entrega a memoria ANTES da edicao. Existe porque o Brain era todo PULL, e PULL falha
+ * onde mais custa — o agente nao busca memoria quando *acha que sabe*. Os dois vao
+ * juntos aqui de proposito: quem monta o `settings.json` a mao pelo `init` sairia sem o
+ * cinto e sem nunca saber que ele existe.
  *
  * Sugerido e nao escrito, pelo mesmo motivo do `.mcp.json`.
  */
@@ -38,6 +45,17 @@ export const SUGESTAO_HOOK = `{
           }
         ]
       }
+    ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|MultiEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "dd-harness cinto"
+          }
+        ]
+      }
     ]
   }
 }`;

package/package.json

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