dd-harness 0.2.0 → 0.4.0

package/LICENSE

@@ -1,11 +1,11 @@
-Copyright (c) 2026 Diego Dias
-
-Todos os direitos reservados.
-
-Este software é publicado no registro npm apenas para distribuição ao seu autor e a
-quem ele autorizar expressamente. Nenhuma permissão de uso, cópia, modificação,
-distribuição ou criação de obras derivadas é concedida por esta publicação.
-
-All rights reserved. This software is published to the npm registry for distribution
-to its author and to those he expressly authorizes. No permission to use, copy,
-modify, distribute, or create derivative works is granted by this publication.
+Copyright (c) 2026 Diego Dias
+
+Todos os direitos reservados.
+
+Este software é publicado no registro npm apenas para distribuição ao seu autor e a
+quem ele autorizar expressamente. Nenhuma permissão de uso, cópia, modificação,
+distribuição ou criação de obras derivadas é concedida por esta publicação.
+
+All rights reserved. This software is published to the npm registry for distribution
+to its author and to those he expressly authorizes. No permission to use, copy,
+modify, distribute, or create derivative works is granted by this publication.

package/README.md

@@ -1,64 +1,64 @@
-# dd-harness
-
-Materializa a **política**, o **briefing** e o **Brain** do
-[dd-harness](https://dd-harness.vercel.app) dentro do seu repositório, para que a sessão
-do agente de código abra já sabendo as regras e as decisões do projeto.
-
-Sem dependência: `fetch`, `crypto` e `fs` são do Node. Um CLI que vive pinado em
-repositório alheio precisa envelhecer bem, e cada dependência é uma chance de não
-envelhecer.
-
-## Instalação
-
-```sh
-npm install -g dd-harness
-```
-
-Ou sem instalar nada:
-
-```sh
-npx dd-harness sync
-```
-
-Requer Node 20 ou mais novo.
-
-## Uso
-
-```sh
-dd-harness init --tenant <espaço> --projeto <projeto>   # prepara o repositório
-dd-harness login --token <token>                        # credencial desta máquina
-dd-harness sync                                         # escreve os artefatos
-dd-harness check [--commit <sha>]                       # mede âncoras e reporta deriva
-dd-harness status                                       # só lê: o que espera julgamento
-```
-
-O token pessoal nasce na tela `/tokens` do serviço. Ele é guardado em
-`~/.dd-harness/credentials.json` (modo `0600`, por origem de API) — **fora** do
-repositório, para não viajar num commit.
-
-## O que aparece no seu repositório
-
-```
-.dd-harness.json      configuração (tenant, projeto, api) — escrita à mão
-CLAUDE.md             SEU arquivo; o sync nunca o reescreve
-dd-harness/           tudo o que é gerado
-  politica.md
-  BRIEFING.md
-  brain/
-  manifest.json
-```
-
-Na raiz fica apenas o **seu** `CLAUDE.md`, que importa a política com a linha
-`@dd-harness/politica.md`. Isso deixa conviverem a parte gerenciada e o que o
-repositório tem de próprio — adotar um projeto existente é acrescentar uma linha, não
-sobrescrever nada.
-
-O `sync` confere esse ponteiro a cada execução, inclusive quando o serviço não mudou:
-import quebrado ou linha ausente faz a sessão abrir **sem política e sem avisar**. Isso
-foi medido, não suposto.
-
-## Deriva
-
-`dd-harness check` mede as âncoras das memórias contra o estado real do repositório e
-reporta o que saiu do lugar. Com `--commit <sha>` ele também cruza as âncoras com o diff
-daquele commit — a memória volta ao code review. Nada bloqueia: avisa.
+# dd-harness
+
+Materializa a **política**, o **briefing** e o **Brain** do
+[dd-harness](https://dd-harness.vercel.app) dentro do seu repositório, para que a sessão
+do agente de código abra já sabendo as regras e as decisões do projeto.
+
+Sem dependência: `fetch`, `crypto` e `fs` são do Node. Um CLI que vive pinado em
+repositório alheio precisa envelhecer bem, e cada dependência é uma chance de não
+envelhecer.
+
+## Instalação
+
+```sh
+npm install -g dd-harness
+```
+
+Ou sem instalar nada:
+
+```sh
+npx dd-harness sync
+```
+
+Requer Node 20 ou mais novo.
+
+## Uso
+
+```sh
+dd-harness init --tenant <espaço> --projeto <projeto>   # prepara o repositório
+dd-harness login --token <token>                        # credencial desta máquina
+dd-harness sync                                         # escreve os artefatos
+dd-harness check [--commit <sha>]                       # mede âncoras e reporta deriva
+dd-harness status                                       # só lê: o que espera julgamento
+```
+
+O token pessoal nasce na tela `/tokens` do serviço. Ele é guardado em
+`~/.dd-harness/credentials.json` (modo `0600`, por origem de API) — **fora** do
+repositório, para não viajar num commit.
+
+## O que aparece no seu repositório
+
+```
+.dd-harness.json      configuração (tenant, projeto, api) — escrita à mão
+CLAUDE.md             SEU arquivo; o sync nunca o reescreve
+dd-harness/           tudo o que é gerado
+  politica.md
+  BRIEFING.md
+  brain/
+  manifest.json
+```
+
+Na raiz fica apenas o **seu** `CLAUDE.md`, que importa a política com a linha
+`@dd-harness/politica.md`. Isso deixa conviverem a parte gerenciada e o que o
+repositório tem de próprio — adotar um projeto existente é acrescentar uma linha, não
+sobrescrever nada.
+
+O `sync` confere esse ponteiro a cada execução, inclusive quando o serviço não mudou:
+import quebrado ou linha ausente faz a sessão abrir **sem política e sem avisar**. Isso
+foi medido, não suposto.
+
+## Deriva
+
+`dd-harness check` mede as âncoras das memórias contra o estado real do repositório e
+reporta o que saiu do lugar. Com `--commit <sha>` ele também cruza as âncoras com o diff
+daquele commit — a memória volta ao code review. Nada bloqueia: avisa.

package/dist/argv.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Leitura de argumentos da linha de comando.
+ *
+ * Vive fora do `index.ts` porque aquele modulo executa o CLI ao ser importado
+ * (`principal()` no topo) — teste que o importasse rodaria o programa inteiro.
+ */
+/**
+ * Os termos livres de uma consulta, sem os pares `--flag valor`.
+ *
+ * Filtrar so o que comeca com `--` deixava o VALOR da flag para tras, e ele entrava na
+ * consulta: `buscar "efeito" --limite 2` virava a pergunta `"efeito 2"`. A busca roda, a
+ * resposta parece valida e responde a outra coisa — quem chamou nao tem como notar.
+ */
+export declare function termosDaConsulta(argv: string[]): string;

package/dist/argv.js

@@ -0,0 +1,27 @@
+/**
+ * Leitura de argumentos da linha de comando.
+ *
+ * Vive fora do `index.ts` porque aquele modulo executa o CLI ao ser importado
+ * (`principal()` no topo) — teste que o importasse rodaria o programa inteiro.
+ */
+/**
+ * Os termos livres de uma consulta, sem os pares `--flag valor`.
+ *
+ * Filtrar so o que comeca com `--` deixava o VALOR da flag para tras, e ele entrava na
+ * consulta: `buscar "efeito" --limite 2` virava a pergunta `"efeito 2"`. A busca roda, a
+ * resposta parece valida e responde a outra coisa — quem chamou nao tem como notar.
+ */
+export function termosDaConsulta(argv) {
+    const termos = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const atual = argv[i];
+        if (atual.startsWith("--")) {
+            // `--flag=valor` carrega o valor no proprio token; `--flag valor` consome o proximo.
+            if (!atual.includes("="))
+                i += 1;
+            continue;
+        }
+        termos.push(atual);
+    }
+    return termos.join(" ").trim();
+}

package/dist/artefato.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Ler e escrever a politica e o briefing do projeto.
+ *
+ * Ate aqui artefato so se editava pela interface, e isso deixava o agente sem saida para a
+ * unica coisa que ele mais precisa saber: a propria politica. O CLI exige que alguem ja
+ * tenha escrito nela que o CLI existe — e era justamente ela que estava fora de alcance.
+ */
+export type TipoDeArtefato = "politica" | "briefing";
+/**
+ * O `GET` devolve o payload inteiro (politica, briefing, pastas e memorias); aqui so o
+ * artefato pedido interessa.
+ *
+ * `null` e `""` significam a mesma coisa para quem le — "ainda nao existe" —, e a diferenca
+ * entre elas e detalhe de como a linha foi parar no banco. Quem chama recebe `existe`, que
+ * e a pergunta real.
+ */
+export declare function leArtefato(raiz: string, tipo: TipoDeArtefato): Promise<{
+    conteudo: string;
+    existe: boolean;
+}>;
+/**
+ * Substituicao total, nao append: quem quer acrescentar um paragrafo le, concatena e
+ * reenvia. Conteudo vazio e valido e significa "apagar" — a linha fica no banco, guardando
+ * quem mexeu por ultimo.
+ */
+export declare function escreveArtefato(raiz: string, tipo: TipoDeArtefato, conteudo: string): Promise<{
+    artefato: string;
+    criou: boolean;
+    tamanho: number;
+}>;

package/dist/artefato.js

@@ -0,0 +1,42 @@
+import { cabecalhos, credencial, pede, recusa } from "./api.js";
+/**
+ * O `GET` devolve o payload inteiro (politica, briefing, pastas e memorias); aqui so o
+ * artefato pedido interessa.
+ *
+ * `null` e `""` significam a mesma coisa para quem le — "ainda nao existe" —, e a diferenca
+ * entre elas e detalhe de como a linha foi parar no banco. Quem chama recebe `existe`, que
+ * e a pergunta real.
+ */
+export async function leArtefato(raiz, tipo) {
+    const { config, token } = await credencial(raiz);
+    const url = new URL(`${config.api}/api/v1/artefatos`);
+    url.searchParams.set("tenant", config.tenant);
+    url.searchParams.set("projeto", config.projeto);
+    const resposta = await pede(url, { headers: cabecalhos(token) });
+    if (!resposta.ok)
+        await recusa(resposta);
+    const payload = (await resposta.json());
+    const conteudo = typeof payload[tipo] === "string" ? payload[tipo] : "";
+    return { conteudo, existe: conteudo.length > 0 };
+}
+/**
+ * Substituicao total, nao append: quem quer acrescentar um paragrafo le, concatena e
+ * reenvia. Conteudo vazio e valido e significa "apagar" — a linha fica no banco, guardando
+ * quem mexeu por ultimo.
+ */
+export async function escreveArtefato(raiz, tipo, conteudo) {
+    const { config, token } = await credencial(raiz);
+    const resposta = await pede(`${config.api}/api/v1/artefatos`, {
+        method: "PUT",
+        headers: cabecalhos(token, true),
+        body: JSON.stringify({
+            tenant: config.tenant,
+            projeto: config.projeto,
+            tipo,
+            conteudo,
+        }),
+    });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return (await resposta.json());
+}

package/dist/brain.d.ts

@@ -0,0 +1,50 @@
+/**
+ * A forma do Brain no contrato `/api/v1`.
+ *
+ * So os tipos: o que o servico devolve, e o que o CLI le. Ate a fase 0 este modulo
+ * tambem transformava o payload em arquivos de disco — o `sync` materializava politica,
+ * briefing e o Brain inteiro no repositorio consumidor. Isso acabou: a politica chega
+ * pelo hook de sessao, e a memoria pela busca, na hora. Nada do dd-harness vive em disco.
+ */
+export type Ancora = {
+    tipo: string;
+    valor: string;
+    sha: string | null;
+};
+export type Memoria = {
+    pasta: string;
+    slug: string;
+    titulo: string;
+    resumo: string;
+    corpo: string;
+    status: "ativa" | "historico";
+    dano: string;
+    invisibilidade: string;
+    externalidade: string;
+    ancoras: Ancora[];
+    revisar_ate: string | null;
+    /** Observacoes de deriva esperando julgamento. Ausente em payload antigo. */
+    deriva_aberta?: number;
+};
+export type Brain = {
+    tenant: {
+        slug: string;
+        nome: string;
+    };
+    projeto: {
+        slug: string;
+        nome: string;
+    };
+    politica?: string | null;
+    briefing?: string | null;
+    pastas: {
+        slug: string;
+        definicao: string;
+    }[];
+    memorias: Memoria[];
+    /**
+     * Memorias que excederam as tentativas de indexacao e nao serao mais tentadas. Ficam
+     * sem embedding — somem da busca semantica — e so este numero denuncia.
+     */
+    travadas_na_fila?: number;
+};

package/dist/brain.js

@@ -0,0 +1,9 @@
+/**
+ * A forma do Brain no contrato `/api/v1`.
+ *
+ * So os tipos: o que o servico devolve, e o que o CLI le. Ate a fase 0 este modulo
+ * tambem transformava o payload em arquivos de disco — o `sync` materializava politica,
+ * briefing e o Brain inteiro no repositorio consumidor. Isso acabou: a politica chega
+ * pelo hook de sessao, e a memoria pela busca, na hora. Nada do dd-harness vive em disco.
+ */
+export {};

package/dist/check.d.ts

@@ -1,5 +1,5 @@
 import { type Tocada } from "./diff.js";
-import type { Brain } from "./materializa.js";
+import type { Brain } from "./brain.js";
 /**
  * `dd-harness check` — resolve as âncoras contra a árvore de trabalho.
  *
@@ -51,6 +51,11 @@ export type ResultadoDoStatus = {
         memoria: string;
         titulo: string;
     }[];
+    /**
+     * Memorias que o indexador desistiu de processar. Sem embedding elas somem da busca
+     * semantica e continuam aparecendo no acervo — o unico sintoma e procurar e nao achar.
+     */
+    travadasNaFila: number;
 };
 /** Separado do IO para poder ser testado sem rede: dado um Brain, o que se mede. */
 export declare function medeAsAncoras(raiz: string, brain: Brain): Promise<Medicao[]>;

package/dist/check.js

@@ -72,6 +72,7 @@ export async function status(raiz) {
         vencidas: ativas
             .filter((m) => m.revisar_ate && new Date(m.revisar_ate).getTime() < agora)
             .map((m) => ({ pasta: m.pasta, memoria: m.slug, titulo: m.titulo })),
+        travadasNaFila: brain.travadas_na_fila ?? 0,
     };
 }
 export async function check(raiz, commit) {

package/dist/curar.d.ts

@@ -1,3 +1,41 @@
+/**
+ * Curadoria pelo agente: ler, editar e arquivar.
+ *
+ * `gravar` sabia criar e mais nada. Uma memoria errada ficava errada, porque corrigir
+ * exigia abrir a interface — e o `CLAUDE.md` trata curadoria como obrigacao ("se
+ * encontrar uma memoria obsoleta ou errada, corrija").
+ *
+ * Editar reaproveita o mesmo markdown de `gravar`: um formato so para as duas operacoes.
+ * Ate a fase 0 o ponto de partida era o arquivo que o `sync` materializava; agora e o
+ * `le`, que busca a memoria no servico e devolve nesse mesmo formato.
+ */
+export type MemoriaDoServico = {
+    pasta: string;
+    slug: string;
+    titulo: string;
+    resumo: string;
+    corpo: string;
+    status: string;
+    dano: string;
+    invisibilidade: string;
+    externalidade: string;
+    revisar_ate: string | null;
+    ancoras: {
+        tipo: string;
+        valor: string;
+        sha: string | null;
+    }[];
+};
+/**
+ * A memoria inteira, no markdown que `gravar` e `editar` consomem.
+ *
+ * Sem materializacao, esta e a unica forma de ler o corpo: a busca devolve so endereco,
+ * titulo e resumo, e o disco nao tem mais nada. Tambem e o ponto de partida de qualquer
+ * edicao — corrigir exige ver o que esta la.
+ */
+export declare function le(raiz: string, endereco: string): Promise<string>;
+/** O formato canonico: o mesmo que `interpreta` le, para o ciclo fechar sem conversao. */
+export declare function comoMarkdown(m: MemoriaDoServico): string;
 export declare function edita(raiz: string, caminho: string): Promise<{
     endereco: string;
     ancoras: number;

package/dist/curar.js

@@ -1,37 +1,48 @@
 import { readFile } from "node:fs/promises";
-import { relative } from "node:path";
 import { cabecalhos, credencial, pede, recusa } from "./api.js";
-import { gravaManifesto, hashDe, leManifesto } from "./config.js";
 import { interpreta } from "./gravar.js";
 /**
- * Curadoria pelo agente: editar e arquivar.
+ * A memoria inteira, no markdown que `gravar` e `editar` consomem.
  *
- * `gravar` sabia criar e mais nada. Uma memoria errada ficava errada, porque corrigir
- * exigia abrir a interface — e o `CLAUDE.md` trata curadoria como obrigacao ("se
- * encontrar uma memoria obsoleta ou errada, corrija").
- *
- * Editar reaproveita o mesmo markdown de `gravar`, de proposito: o agente edita o arquivo
- * que o `sync` materializou e manda de volta. Um formato so para as duas operacoes, e o
- * que ele ja sabe ler.
- */
-/**
- * Depois que o servico aceita, o arquivo em disco deixa de ser "edicao nao enviada" — e o
- * manifesto tem que saber, senao o `sync` seguinte para com "editado a mao" e a unica saida
- * que resta e descartar o arquivo. O ciclo materializa-corrige-envia travava justamente
- * aqui, com o servico ja atualizado.
- *
- * Guarda o hash do que foi enviado, nao do que o servico devolveria: o `sync` seguinte
- * reescreve o arquivo na forma canonica quando o ETag mudar.
+ * Sem materializacao, esta e a unica forma de ler o corpo: a busca devolve so endereco,
+ * titulo e resumo, e o disco nao tem mais nada. Tambem e o ponto de partida de qualquer
+ * edicao — corrigir exige ver o que esta la.
  */
-async function marcaComoEnviado(raiz, caminho, conteudo) {
-    const chave = relative(raiz, caminho).split("\\").join("/");
-    const manifesto = await leManifesto(raiz);
-    // Arquivo de fora do repositorio (um rascunho em /tmp, por exemplo) nao esta no
-    // manifesto e nao deve entrar: o manifesto descreve o que o `sync` materializou.
-    if (!manifesto.arquivos[chave])
-        return;
-    manifesto.arquivos[chave] = hashDe(conteudo);
-    await gravaManifesto(raiz, manifesto);
+export async function le(raiz, endereco) {
+    const { config, token } = await credencial(raiz);
+    const url = new URL(`${config.api}/api/v1/memorias/${endereco}`);
+    url.searchParams.set("tenant", config.tenant);
+    url.searchParams.set("projeto", config.projeto);
+    const resposta = await pede(url, { headers: cabecalhos(token) });
+    if (!resposta.ok)
+        await recusa(resposta);
+    return comoMarkdown((await resposta.json()));
+}
+/** O formato canonico: o mesmo que `interpreta` le, para o ciclo fechar sem conversao. */
+export function comoMarkdown(m) {
+    const ancoras = m.ancoras.length
+        ? `\n## Âncoras\n\n${m.ancoras.map((a) => `- \`${a.valor}\``).join("\n")}\n`
+        : "";
+    return [
+        "---",
+        `name: ${m.slug}`,
+        `titulo: ${m.titulo}`,
+        `description: ${m.resumo}`,
+        `pasta: ${m.pasta}`,
+        ...(m.revisar_ate ? [`revisar-ate: ${m.revisar_ate.slice(0, 10)}`] : []),
+        "---",
+        "",
+        m.corpo.trim(),
+        "",
+        "## Os três filtros",
+        "",
+        `**Dano:** ${m.dano}`,
+        "",
+        `**Invisibilidade:** ${m.invisibilidade}`,
+        "",
+        `**Externalidade:** ${m.externalidade}`,
+        ancoras,
+    ].join("\n");
 }
 export async function edita(raiz, caminho) {
     const { config, token } = await credencial(raiz);
@@ -55,7 +66,6 @@ export async function edita(raiz, caminho) {
     });
     if (!resposta.ok)
         await recusa(resposta);
-    await marcaComoEnviado(raiz, caminho, cru);
     return { endereco, ancoras: memoria.ancoras.length };
 }
 export async function arquiva(raiz, endereco, opcoes) {

package/dist/diff.d.ts

@@ -1,4 +1,4 @@
-import type { Brain } from "./materializa.js";
+import type { Brain } from "./brain.js";
 /**
  * Quais memorias falam do que este commit mudou.
  *
@@ -21,5 +21,10 @@ export type Tocada = {
 /**
  * Cruza caminhos com ancoras. A ancora casa quando e o proprio caminho ou quando e um
  * diretorio que o contem — `supabase/migrations` tem que casar com a migration nova.
+ *
+ * Ancora de trecho (`arquivo.js#alvo`) casa pelo ARQUIVO: o `git diff-tree` devolve
+ * caminho puro, nunca com `#`, entao comparar o valor inteiro nao casava nunca — e em
+ * silencio, porque nao casar e resultado valido. O alvo continua no `Tocada.ancora`, que
+ * e o que a mensagem mostra: quem le precisa saber qual trecho a memoria guarda.
  */
 export declare function memoriasTocadas(brain: Brain, caminhos: string[]): Tocada[];

package/dist/diff.js

@@ -30,6 +30,11 @@ export async function caminhosDoCommit(raiz, commit) {
 /**
  * Cruza caminhos com ancoras. A ancora casa quando e o proprio caminho ou quando e um
  * diretorio que o contem — `supabase/migrations` tem que casar com a migration nova.
+ *
+ * Ancora de trecho (`arquivo.js#alvo`) casa pelo ARQUIVO: o `git diff-tree` devolve
+ * caminho puro, nunca com `#`, entao comparar o valor inteiro nao casava nunca — e em
+ * silencio, porque nao casar e resultado valido. O alvo continua no `Tocada.ancora`, que
+ * e o que a mensagem mostra: quem le precisa saber qual trecho a memoria guarda.
  */
 export function memoriasTocadas(brain, caminhos) {
     const tocadas = [];
@@ -37,7 +42,8 @@ export function memoriasTocadas(brain, caminhos) {
         if (memoria.status !== "ativa")
             continue;
         for (const ancora of memoria.ancoras) {
-            const casa = caminhos.some((c) => c === ancora.valor || c.startsWith(`${ancora.valor}/`));
+            const alvo = ancora.valor.split("#")[0];
+            const casa = caminhos.some((c) => c === alvo || c.startsWith(`${alvo}/`));
             if (casa) {
                 tocadas.push({
                     pasta: memoria.pasta,

package/dist/gravar.js

@@ -46,9 +46,18 @@ export function interpreta(texto) {
             throw new Error(`frontmatter sem \`${chave}\`.`);
     }
     // O corpo vai ate a secao dos filtros; dali para baixo e metadado, nao conteudo.
-    const corte = resto.search(/\n##\s+Os tr[êe]s filtros\s*\n/i);
-    if (corte === -1)
+    const cabecalhoDosFiltros = /\n##\s+Os tr[êe]s filtros\s*\n/gi;
+    const ocorrencias = [...resto.matchAll(cabecalhoDosFiltros)];
+    if (ocorrencias.length === 0)
         throw new Error("falta a seção `## Os três filtros`.");
+    // Duas ocorrencias tornam o arquivo ambiguo: cortar na primeira trunca o corpo (e os
+    // filtros ainda saem certos da segunda, entao grava e perde dado sem avisar), e cortar
+    // na ultima escolheria em silencio qual secao e a de verdade. Recusar diz o que houve.
+    if (ocorrencias.length > 1) {
+        throw new Error("a seção `## Os três filtros` aparece mais de uma vez — deixe só a real, " +
+            "ou reescreva a citação no corpo (por exemplo, entre crases).");
+    }
+    const corte = ocorrencias[0].index;
     const corpo = resto
         .slice(0, corte)
         .replace(/<!--[\s\S]*?-->/g, "")

package/dist/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
+import { termosDaConsulta } from "./argv.js";
 import { check, status } from "./check.js";
 import { leConfigDoRepo, guardaToken } from "./config.js";
 import { grava } from "./gravar.js";
-import { init, SUGESTAO_MCP } from "./init.js";
-import { LINHA_DE_IMPORT } from "./materializa.js";
+import { init, SUGESTAO_HOOK, SUGESTAO_MCP } from "./init.js";
+import { buscaPolitica } from "./politica.js";
 import { busca } from "./buscar.js";
-import { arquiva, edita } from "./curar.js";
+import { arquiva, edita, le } from "./curar.js";
 import { criaPasta } from "./pasta.js";
 import { criaProjeto } from "./projeto.js";
-import { sync } from "./sync.js";
 /**
  * `dd-harness` — o cliente que materializa os artefatos no repositorio.
  *
@@ -17,7 +17,7 @@ import { sync } from "./sync.js";
  * em repositorio alheio tem que envelhecer bem, e cada dependencia e uma chance de nao
  * envelhecer.
  */
-const AJUDA = `dd-harness — materializa política, briefing e Brain no repositório
+const AJUDA = `dd-harness — a política e o Brain do projeto, no serviço
 
   dd-harness login --token <token> [--api <url>]
                                      guarda a credencial desta máquina
@@ -33,61 +33,35 @@ const AJUDA = `dd-harness — materializa política, briefing e Brain no reposit
                      [--substituida-por <pasta>/<slug>]
                                      tira de circulação sem apagar
   dd-harness buscar "<pergunta>"     acha memória por relevância, não por arquivo
-  dd-harness sync                    escreve os artefatos em disco
+  dd-harness ler <pasta>/<slug>      imprime a memória inteira, no formato de gravar
   dd-harness check [--commit <sha>]  mede as âncoras e reporta a deriva
   dd-harness status                  só lê: o tamanho do Brain e o que espera julgamento
+  dd-harness politica [--hook]       imprime a política do serviço
+                                     saída 0 = veio; 3 = projeto sem política;
+                                     1 = não consegui buscar
+                                     --hook: fala o protocolo do SessionStart do
+                                     Claude Code, para pôr a política no contexto
   dd-harness --help
 
-O gerado vive em dd-harness/. Na raiz fica só o seu CLAUDE.md, que importa a
-política com a linha ${LINHA_DE_IMPORT}
+Nada do dd-harness fica em disco: a política chega pelo hook de sessão, e a
+memória pela busca, na hora.
 `;
-/** O aviso existe porque o import falha em silêncio — foi medido, não suposto. */
-function avisaSobreOPonteiro(ponteiro) {
-    if (ponteiro === "ok" || ponteiro === "sem-politica")
-        return;
-    // O import pendurado e o inverso dos outros dois: a linha esta la, o alvo e que nao
-    // existe. Dizer "acrescente a linha" aqui mandaria a pessoa para o lugar errado.
-    if (ponteiro === "aponta-para-o-vazio") {
-        console.error([
-            "",
-            `AVISO: o CLAUDE.md importa ${LINHA_DE_IMPORT}, mas não há política no serviço.`,
-            "O arquivo apontado não existe, e import quebrado falha em silêncio: a sessão abre",
-            "sem protocolo e nada avisa.",
-            "",
-            "Escreva a política do projeto no serviço, ou tire a linha do CLAUDE.md.",
-        ].join("\n"));
-        return;
-    }
-    const motivo = ponteiro === "sem-claude-md"
-        ? "não há CLAUDE.md na raiz"
-        : "o CLAUDE.md da raiz não importa a política";
-    console.error([
-        "",
-        `AVISO: ${motivo}.`,
-        "A política existe no serviço e está em disco, mas não chega à sessão: o import",
-        "ausente falha em silêncio, e a sessão abre sem protocolo sem avisar ninguém.",
-        "",
-        `Acrescente esta linha ao CLAUDE.md da raiz:  ${LINHA_DE_IMPORT}`,
-        "Ou rode: dd-harness init --tenant <t> --projeto <p>",
-    ].join("\n"));
-}
 /**
  * Os ganchos sao IMPRESSOS, nunca instalados. `.git/hooks` nao e versionado e nao e
  * nosso: escrever la dentro sem a pessoa pedir e o mesmo tipo de invasao que
  * sobrescrever o CLAUDE.md dela. Quem cola, decide.
  */
 const GANCHOS = `
-Opcional — dois ganchos que valem a pena:
+Opcional — o gancho que devolve a memória ao code review:
 
   .git/hooks/post-commit   (avisa quais memórias falam do que você mudou)
     #!/bin/sh
     dd-harness check --commit "$(git rev-parse HEAD)" || true
 
-  .claude/settings.json    (na abertura da sessão, o que espera julgamento)
-    "hooks": { "SessionStart": [{ "hooks": [{ "type": "command",
-      "command": "dd-harness status" }] }] }
+Termina em sucesso mesmo com deriva: avisa, não bloqueia.
 
-Os dois terminam em sucesso mesmo com deriva: avisam, não bloqueiam.`;
+O hook da política (\`dd-harness politica --hook\`) é outra coisa, e não é
+opcional — \`dd-harness init\` imprime a linha para o \`.claude/settings.json\`.`;
 function argumento(argv, nome) {
     const i = argv.indexOf(`--${nome}`);
     return i >= 0 ? argv[i + 1] : undefined;
@@ -104,12 +78,19 @@ async function comandoInit(argv) {
         api: argumento(argv, "api"),
     });
     console.log(r.config === "criada" ? "criado  .dd-harness.json" : "mantido .dd-harness.json");
-    console.log({
-        criado: "criado  CLAUDE.md com a linha de import",
-        "linha-acrescentada": "ajustado CLAUDE.md — linha de import acrescentada ao seu",
-        "ja-tinha-a-linha": "mantido CLAUDE.md — já importava a política",
-    }[r.claudeMd]);
-    console.log("\nAgora: dd-harness login --token <token> && dd-harness sync");
+    console.log("\nAgora: dd-harness login --token <token>");
+    // O hook vem primeiro e nao e opcional: sem ele a sessao abre sem politica, que e a
+    // falha que este projeto existe para combater. O MCP e conveniencia; este, nao.
+    if (r.hook === "ja-declarado") {
+        console.log("\nmantido .claude/settings.json — o hook da política já está declarado");
+    }
+    else {
+        console.log("\nOBRIGATÓRIO: o hook que carrega a política no início de cada sessão." +
+            "\nSem ele a sessão abre sem protocolo, e nada avisa. Acrescente ao" +
+            "\n`.claude/settings.json` (não escrevo nele: o arquivo é seu e pode já" +
+            "\nter hooks e permissões):\n");
+        console.log(SUGESTAO_HOOK);
+    }
     if (r.mcp === "ja-declarado") {
         console.log("\nmantido .mcp.json — o servidor dd-harness já está declarado");
         return;
@@ -142,7 +123,7 @@ async function comandoEditar(argv) {
     }
     const r = await edita(process.cwd(), caminho);
     console.log(`editado  ${r.endereco}`);
-    console.log(`  ${r.ancoras} âncora(s). Rode \`dd-harness sync\` para materializar.`);
+    console.log(`  ${r.ancoras} âncora(s).`);
 }
 const MOTIVOS = ["obsoleta", "incorreta", "fora_dos_filtros"];
 async function comandoArquivar(argv) {
@@ -161,10 +142,23 @@ async function comandoArquivar(argv) {
         substituidaPor: argumento(argv, "substituida-por"),
     });
     console.log(`arquivado  ${r.endereco} (${r.motivo})`);
-    console.log("  foi para o histórico, não foi apagada. Rode `dd-harness sync`.");
+    console.log("  foi para o histórico, não foi apagada.");
+}
+/**
+ * A memoria inteira no stdout, no mesmo markdown que `gravar` e `editar` consomem.
+ *
+ * Sem materializacao este e o unico caminho para o corpo: a busca devolve so endereco,
+ * titulo e resumo. Tambem e o ponto de partida de toda edicao — corrigir exige ver.
+ */
+async function comandoLer(argv) {
+    const endereco = argv[0];
+    if (!endereco || endereco.startsWith("-")) {
+        throw new Error("uso: dd-harness ler <pasta>/<slug>");
+    }
+    console.log(await le(process.cwd(), endereco));
 }
 async function comandoBuscar(argv) {
-    const consulta = argv.filter((a) => !a.startsWith("--")).join(" ").trim();
+    const consulta = termosDaConsulta(argv);
     if (!consulta)
         throw new Error('uso: dd-harness buscar "<pergunta>"');
     const limite = Number(argumento(argv, "limite")) || undefined;
@@ -186,36 +180,6 @@ async function comandoBuscar(argv) {
         console.log(`    ${a.resumo}`);
     }
 }
-async function comandoSync() {
-    const resultado = await sync(process.cwd());
-    if (resultado.tipo === "editado-a-mao") {
-        console.error([
-            "parei sem escrever nada: estes arquivos foram editados à mão.",
-            ...resultado.arquivos.map((a) => `  ${a}`),
-            "",
-            "O disco é projeção do serviço, uma direção só. Duas saídas:",
-            "",
-            "  1. Leve a edição para o serviço — `dd-harness editar <arquivo>` para cada um",
-            "     acima. É o caminho normal de corrigir memória, e destrava o sync.",
-            "  2. Descarte a edição local (git checkout / apague o arquivo) e sincronize.",
-        ].join("\n"));
-        process.exitCode = 1;
-        return;
-    }
-    if (resultado.tipo === "sem-mudanca") {
-        console.log("nada mudou no serviço — disco já está em dia.");
-    }
-    else {
-        for (const a of resultado.escritos)
-            console.log(`escrito  ${a}`);
-        for (const a of resultado.removidos)
-            console.log(`removido ${a}`);
-        if (!resultado.escritos.length && !resultado.removidos.length) {
-            console.log("conteúdo novo do serviço, sem diferença em disco.");
-        }
-    }
-    avisaSobreOPonteiro(resultado.ponteiro);
-}
 async function comandoCheck(argv) {
     const r = await check(process.cwd(), argumento(argv, "commit"));
     if (r.medidas === 0) {
@@ -261,6 +225,71 @@ async function comandoCheck(argv) {
         }
     }
 }
+/**
+ * Imprime a politica no stdout, para o hook `SessionStart` injetar no contexto.
+ *
+ * Os codigos de saida sao o contrato com o hook, e existem para separar duas coisas que
+ * um "falhou" generico colapsaria: projeto novo (que precisa de briefing) de politica
+ * inalcancavel (que precisa PARAR a sessao). Mudar estes numeros quebra o hook.
+ */
+async function comandoPolitica(argv) {
+    const r = await buscaPolitica(process.cwd());
+    // `--hook`: fala o protocolo do SessionStart do Claude Code, que injeta
+    // `additionalContext` no contexto da sessao. Sem a flag, saida legivel para quem roda
+    // no terminal. A diferenca importa: o hook precisa que o AVISO chegue ao modelo, e
+    // stderr so chega ao transcript — aviso que o modelo nao le e o mesmo que silencio.
+    if (argv.includes("--hook")) {
+        console.log(JSON.stringify({ hookSpecificOutput: contextoDaSessao(r) }));
+        return;
+    }
+    if (r.estado === "ok") {
+        console.log(r.conteudo);
+        return;
+    }
+    if (r.estado === "sem-politica") {
+        console.error("Este projeto ainda não tem política — nunca foi briefado. Rode `/briefar`.");
+        process.exitCode = 3;
+        return;
+    }
+    console.error(`não consegui buscar a política: ${r.motivo}`);
+    process.exitCode = 1;
+}
+/**
+ * O que o hook injeta no contexto, por estado.
+ *
+ * Sai sempre com codigo 0: o que precisa chegar ao modelo e o TEXTO, e um codigo de erro
+ * so faria o Claude Code registrar falha no transcript — que ninguem le — enquanto a
+ * sessao seguiria sem saber que esta sem protocolo.
+ */
+function contextoDaSessao(r) {
+    const base = { hookEventName: "SessionStart" };
+    if (r.estado === "ok") {
+        return {
+            ...base,
+            additionalContext: "# Política deste projeto (carregada do dd-harness)\n\n" +
+                "As regras abaixo valem para esta sessão inteira.\n\n" +
+                r.conteudo,
+        };
+    }
+    if (r.estado === "sem-politica") {
+        return {
+            ...base,
+            additionalContext: "AVISO DO DD-HARNESS: este projeto existe no serviço mas **nunca foi briefado** " +
+                "— não há política.\n\nIsto não é uma falha: é um projeto novo. Antes de " +
+                "implementar qualquer coisa, diga isso ao usuário e proponha rodar `/briefar`.",
+        };
+    }
+    return {
+        ...base,
+        additionalContext: "PARE: NÃO FOI POSSÍVEL CARREGAR A POLÍTICA DESTE PROJETO.\n\n" +
+            `Motivo: ${r.motivo}\n\n` +
+            "A política pode existir no serviço e não ter chegado até aqui, então esta sessão " +
+            "está **sem protocolo** — as proibições e a regra do OK não foram carregadas.\n\n" +
+            "Antes de qualquer outra coisa: avise o usuário com estas palavras e **não " +
+            "modifique nenhum arquivo** até ele decidir como prosseguir. Seguir como se nada " +
+            "tivesse acontecido é exatamente a falha que este projeto combate.",
+    };
+}
 async function comandoStatus() {
     const r = await status(process.cwd());
     // O acervo vem primeiro, e sempre: e a resposta para "o que ha no Brain deste projeto?",
@@ -276,6 +305,14 @@ async function comandoStatus() {
             (arquivadas ? ` e ${arquivadas} arquivada(s)` : "") +
             (detalhe ? ` — ${detalhe}` : ""));
     }
+    // Antes do early return abaixo: fila travada nao e "julgamento esperando", e sumiria
+    // justamente na sessao mais comum — a que nao tem deriva nem vencida.
+    if (r.travadasNaFila > 0) {
+        console.log("");
+        console.log(`AVISO: ${r.travadasNaFila} memória(s) desistiram de ser indexadas e não entram na busca semântica.`);
+        console.log("  O indexador tentou 5 vezes e parou. Rode `pnpm worker --reindexar`;");
+        console.log("  se repetir, o motivo está em `embedding_queue.ultimo_erro`.");
+    }
     if (!r.comDeriva.length && !r.vencidas.length) {
         console.log("Nada esperando julgamento.");
         return;
@@ -327,9 +364,8 @@ async function comandoPasta(argv) {
 }
 /**
  * O agente escreve o arquivo — que e o que ele ja fazia no modelo file-based — e este
- * comando o transforma em requisicao. O arquivo nao fica no repositorio: quem
- * materializa e o `sync`, a partir do servico, para nao existir copia escrita a mao ao
- * lado da copia gerada.
+ * comando o transforma em requisicao. O arquivo e so o veiculo: depois de gravado, a
+ * memoria vive no servico, e quem quiser le-la usa a busca. Nada fica em disco.
  */
 async function comandoGravar(argv) {
     const caminho = argv[0];
@@ -338,8 +374,7 @@ async function comandoGravar(argv) {
     }
     const r = await grava(process.cwd(), caminho);
     console.log(`gravado  ${r.endereco}`);
-    console.log(`  ${r.ancoras} âncora(s), valendo para ${r.projetos} projeto(s).` +
-        " Rode `dd-harness sync` para materializar.");
+    console.log(`  ${r.ancoras} âncora(s), valendo para ${r.projetos} projeto(s).`);
 }
 async function principal() {
     const [comando, ...resto] = process.argv.slice(2);
@@ -358,14 +393,16 @@ async function principal() {
             return comandoEditar(resto);
         case "arquivar":
             return comandoArquivar(resto);
+        case "ler":
+            return comandoLer(resto);
         case "buscar":
             return comandoBuscar(resto);
-        case "sync":
-            return comandoSync();
         case "check":
             return comandoCheck(resto);
         case "status":
             return comandoStatus();
+        case "politica":
+            return comandoPolitica(resto);
         case "--help":
         case "-h":
         case undefined:

package/dist/init.d.ts

@@ -1,16 +1,37 @@
+/**
+ * Prepara um repositorio para o dd-harness.
+ *
+ * Escreve UM arquivo: o `.dd-harness.json`, que diz a que projeto este repositorio
+ * pertence. Todo o resto e sugestao impressa, para quem cola decidir.
+ *
+ * Ate a fase 0 este comando tambem escrevia uma linha de import no `CLAUDE.md`, que
+ * apontava para a politica materializada em disco. Isso acabou: a politica chega pelo
+ * hook de sessao, e nada do dd-harness fica em disco.
+ */
 export type ResultadoDoInit = {
     config: "criada" | "ja-existia";
-    claudeMd: "criado" | "linha-acrescentada" | "ja-tinha-a-linha";
     mcp: "ja-declarado" | "a-declarar";
+    hook: "ja-declarado" | "a-declarar";
 };
 /**
  * O `.mcp.json` e sugerido, nunca escrito.
  *
- * Pelo mesmo motivo do `CLAUDE.md` da raiz: o arquivo e do repositorio, pode ja declarar
- * outros servidores, e mesclar JSON alheio e onde falha silenciosa nasce — entrada errada
- * nao da erro, a ferramenta so nao aparece. Quem cola sabe o que colou.
+ * O arquivo e do repositorio, pode ja declarar outros servidores, e mesclar JSON alheio e
+ * onde falha silenciosa nasce — entrada errada nao da erro, a ferramenta so nao aparece.
+ * Quem cola sabe o que colou.
  */
 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.
+ *
+ * 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.
+ *
+ * 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 function init(raiz: string, dados: {
     tenant: string;
     projeto: string;

package/dist/init.js

@@ -1,28 +1,12 @@
 import { readFile, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { CAMINHO_CONFIG } from "./config.js";
-import { LINHA_DE_IMPORT } from "./materializa.js";
-/**
- * Prepara um repositorio para o dd-harness.
- *
- * Funciona nos dois casos, e o segundo e o que importa para a ambicao de adotar projeto
- * que ja existe: se nao ha `CLAUDE.md`, cria um com a linha de import; se **ja ha**,
- * acrescenta a linha ao que voce escreveu, sem tocar no resto. Adotar um projeto vira
- * uma linha, e nao um ritual de mover arquivo.
- */
-const CABECALHO = `# CLAUDE.md
-
-Este arquivo é seu: escreva aqui o que for específico deste repositório.
-
-A linha abaixo importa a política gerenciada pelo dd-harness. **Não a remova** — sem
-ela a sessão abre sem protocolo, e nada avisa.
-`;
 /**
  * O `.mcp.json` e sugerido, nunca escrito.
  *
- * Pelo mesmo motivo do `CLAUDE.md` da raiz: o arquivo e do repositorio, pode ja declarar
- * outros servidores, e mesclar JSON alheio e onde falha silenciosa nasce — entrada errada
- * nao da erro, a ferramenta so nao aparece. Quem cola sabe o que colou.
+ * O arquivo e do repositorio, pode ja declarar outros servidores, e mesclar JSON alheio e
+ * onde falha silenciosa nasce — entrada errada nao da erro, a ferramenta so nao aparece.
+ * Quem cola sabe o que colou.
  */
 export const SUGESTAO_MCP = `{
   "mcpServers": {
@@ -32,6 +16,31 @@ export const SUGESTAO_MCP = `{
     }
   }
 }`;
+/**
+ * O hook que carrega a politica no inicio de cada sessao.
+ *
+ * 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.
+ *
+ * Sugerido e nao escrito, pelo mesmo motivo do `.mcp.json`.
+ */
+export const SUGESTAO_HOOK = `{
+  "hooks": {
+    "SessionStart": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "dd-harness politica --hook",
+            "statusMessage": "Carregando a política do dd-harness..."
+          }
+        ]
+      }
+    ]
+  }
+}`;
 async function declaraMcp(raiz) {
     try {
         const cru = await readFile(join(raiz, ".mcp.json"), "utf8");
@@ -43,6 +52,26 @@ async function declaraMcp(raiz) {
         return "a-declarar";
     }
 }
+/**
+ * O hook ja esta declarado?
+ *
+ * Procura pelo COMANDO, nao pela forma: `settings.json` aceita varios formatos de
+ * matcher, e quem ja tem o hook pode te-lo escrito de outro jeito. O que importa e se
+ * `dd-harness politica` roda no inicio da sessao.
+ */
+async function declaraHook(raiz) {
+    for (const arquivo of [".claude/settings.json", ".claude/settings.local.json"]) {
+        try {
+            const cru = await readFile(join(raiz, arquivo), "utf8");
+            if (cru.includes("dd-harness politica"))
+                return "ja-declarado";
+        }
+        catch {
+            // Sem arquivo: segue para o proximo.
+        }
+    }
+    return "a-declarar";
+}
 export async function init(raiz, dados) {
     const caminhoConfig = join(raiz, CAMINHO_CONFIG);
     let config = "ja-existia";
@@ -58,27 +87,9 @@ export async function init(raiz, dados) {
         await writeFile(caminhoConfig, `${JSON.stringify(conteudo, null, 2)}\n`, "utf8");
         config = "criada";
     }
-    const caminhoClaude = join(raiz, "CLAUDE.md");
-    let claudeMd;
-    let atual = null;
-    try {
-        atual = await readFile(caminhoClaude, "utf8");
-    }
-    catch {
-        atual = null;
-    }
-    if (atual === null) {
-        await writeFile(caminhoClaude, `${CABECALHO}\n${LINHA_DE_IMPORT}\n`, "utf8");
-        claudeMd = "criado";
-    }
-    else if (atual.includes(LINHA_DE_IMPORT)) {
-        claudeMd = "ja-tinha-a-linha";
-    }
-    else {
-        // Acrescenta no fim, sem reescrever nada do que ja estava la.
-        const separador = atual.endsWith("\n") ? "\n" : "\n\n";
-        await writeFile(caminhoClaude, `${atual}${separador}${LINHA_DE_IMPORT}\n`, "utf8");
-        claudeMd = "linha-acrescentada";
-    }
-    return { config, claudeMd, mcp: await declaraMcp(raiz) };
+    return {
+        config,
+        mcp: await declaraMcp(raiz),
+        hook: await declaraHook(raiz),
+    };
 }

package/dist/materializa.d.ts

@@ -44,6 +44,11 @@ export type Brain = {
         definicao: string;
     }[];
     memorias: Memoria[];
+    /**
+     * Memorias que excederam as tentativas de indexacao e nao serao mais tentadas. Ficam
+     * sem embedding — somem da busca semantica — e so este numero denuncia.
+     */
+    travadas_na_fila?: number;
 };
 export declare function arquivoDaMemoria(m: Memoria): string;
 export declare function arquivoDoIndice(brain: Brain): string;

package/dist/politica.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A politica do projeto, buscada no servico na hora.
+ *
+ * Existe para o hook `SessionStart`: sem materializacao em disco, e ele quem garante que
+ * nenhuma sessao abre sem protocolo. Por isso o retorno separa TRES situacoes que um
+ * "deu erro" colapsaria — e cada uma pede uma reacao diferente de quem chamou:
+ *
+ * - `ok`: a politica existe e veio. Segue a sessao.
+ * - `sem-politica`: o projeto existe e nunca foi briefado. NAO e falha: a saida e rodar o
+ *   briefing. Tratar como erro faria todo projeto novo parecer quebrado.
+ * - `inalcancavel`: rede, timeout, 5xx, credencial, projeto inexistente. A politica pode
+ *   existir e nao chegou — e ai a sessao precisa PARAR, porque seguir sem ela e
+ *   exatamente a falha que este projeto combate.
+ *
+ * A diferenca entre as duas ultimas e o que o `GET /api/v1/artefatos` responde: `404` e
+ * "nao ha projeto"; `200` com `politica` nula e "existe, nunca briefado".
+ */
+export type ResultadoDaPolitica = {
+    estado: "ok";
+    conteudo: string;
+} | {
+    estado: "sem-politica";
+} | {
+    estado: "inalcancavel";
+    motivo: string;
+};
+export declare function buscaPolitica(raiz: string): Promise<ResultadoDaPolitica>;

package/dist/politica.js

@@ -0,0 +1,35 @@
+import { cabecalhos, credencial, pede } from "./api.js";
+export async function buscaPolitica(raiz) {
+    let config;
+    try {
+        config = await credencial(raiz);
+    }
+    catch (erro) {
+        // Sem `.dd-harness.json` ou sem token nao da para nem perguntar. E inalcancavel, nao
+        // "sem politica": a politica pode muito bem existir do outro lado.
+        return { estado: "inalcancavel", motivo: mensagem(erro) };
+    }
+    const url = new URL(`${config.config.api}/api/v1/artefatos`);
+    url.searchParams.set("tenant", config.config.tenant);
+    url.searchParams.set("projeto", config.config.projeto);
+    try {
+        const resposta = await pede(url, { headers: cabecalhos(config.token) });
+        if (!resposta.ok) {
+            const { erro } = (await resposta.json().catch(() => ({})));
+            return {
+                estado: "inalcancavel",
+                motivo: erro ?? `a API respondeu ${resposta.status}.`,
+            };
+        }
+        const payload = (await resposta.json());
+        const conteudo = payload.politica?.trim();
+        // Vazio e nulo sao a mesma coisa aqui, e os dois significam "nunca foi escrita".
+        if (!conteudo)
+            return { estado: "sem-politica" };
+        return { estado: "ok", conteudo };
+    }
+    catch (erro) {
+        return { estado: "inalcancavel", motivo: mensagem(erro) };
+    }
+}
+const mensagem = (erro) => erro instanceof Error ? erro.message : String(erro);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "dd-harness",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "type": "module",
-  "description": "Materializa politica, briefing e Brain do dd-harness no repositorio. Sem dependencia: fetch, crypto e fs sao do Node.",
+  "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",
   "author": "Diego Dias",
   "keywords": [