synthesisui 0.16.419 → 0.16.421

package/dist/install-marks.js

@@ -226,7 +226,16 @@
  *
  * O que o cliente ganha ao rodar `upgrade`: a lista responde ao espaço, como a caixa promete.
  */
-export const MATERIALISER_SINCE = "0.16.416";
+/**
+ * 0.16.416 -> 0.16.421 em 12/09, e o passo 1 deu **SIM**: muda um byte que cai na pasta dele.
+ *
+ * O filtro do hook em `.claude/settings.json` era `Write|Edit|MultiEdit` e passa a incluir a
+ * escrita por shell. Quem instalou antes tem no arquivo dele o filtro estreito que NÓS escrevemos,
+ * e sem rodar o comando ele fica com uma checagem que cala em toda edição em lote. O `upgrade`
+ * chama `wireAgent`, então rodar o comando é o caminho de volta - e ele só alarga a string que era
+ * nossa, nunca um filtro que uma pessoa escreveu.
+ */
+export const MATERIALISER_SINCE = "0.16.421";
 /**
  * A ÚLTIMA VERSÃO EM QUE O QUE O HOOK RODA MUDOU.
  *
@@ -334,8 +343,8 @@ export const MATERIALISER_SINCE = "0.16.416";
  * A frase viaja ao lado da versão porque as duas são uma coisa só: quem move a marca troca a
  * explicação no mesmo lugar, em vez de deixar o CI citando a causa da marca anterior.
  */
-export const COUNTED_DIFFERENTLY_SINCE = "0.16.408";
-export const COUNTED_DIFFERENTLY = "this run counts every length in a shorthand - that version counted only the first";
+export const COUNTED_DIFFERENTLY_SINCE = "0.16.421";
+export const COUNTED_DIFFERENTLY = "this run counts the utilities of your own theme - that version counted only `var(--token)`";
 /**
  * 0.16.408 -> 0.16.413 em 10/09: o hook passa a DIZER o valor que nada nomeia. Ele silenciava toda
  * deriva sem token de destino - a decisão estava escrita como "não vale interromper, porque o único
@@ -344,7 +353,20 @@ export const COUNTED_DIFFERENTLY = "this run counts every length in a shorthand
  * e nós engolimos". Agora sai `line 12  #ff00aa`, sem uma única proposta de nome nosso. Um hook
  * pinado antes desta versão aconselha MENOS, que é a régua desta marca.
  */
-export const CHECKER_SINCE = "0.16.419";
+/**
+ * 0.16.419 -> 0.16.421 em 12/09: o hook passa a rodar quando o ARQUIVO muda, e não só quando o
+ * agente usa a ferramenta de edição.
+ *
+ * MEDIDO no `codelevel`, três sessões: toda edição em lote passou por comando de shell e a
+ * checagem produziu **0 linhas**; na única edição feita pela ferramenta de edição ela falou na
+ * hora. Um hook pinado antes desta versão fica calado em toda escrita por shell, que é a forma
+ * como um agente edita em lote - aconselha MENOS, e é a régua desta marca.
+ *
+ * E ele passa a contar a utility do tema DELE como uso de token: num projeto cujo idioma é
+ * utility, um arquivo escrito inteiro no vocabulário do sistema recebia zero. A contagem em si é a
+ * outra marca - ver `COUNTED_DIFFERENTLY_SINCE`, que sobe no mesmo diff.
+ */
+export const CHECKER_SINCE = "0.16.421";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *
@@ -793,7 +815,7 @@ export const CHECKER_SINCE = "0.16.419";
  * deveriam estar lá. Quem tem censo gravado precisa de um `sync` para a fila de trabalho dele ser a
  * real; ver o livro-razão de `corpus.spec.ts`.
  */
-export const READER_SINCE = "0.16.417";
+export const READER_SINCE = "0.16.421";
 /**
  * O QUE ESTÁ INSTALADO AQUI FICOU PARA TRÁS - e as DUAS condições que fazem isso ser verdade.
  *

package/dist/merge-census.js

@@ -237,11 +237,20 @@ export function mergeCensus(list) {
     const named = totals.tokenUses + (totals.ownUses ?? 0);
     const denominator = named + totals.values + (totals.phantomUses ?? 0);
     const complete = list.every((c) => c.totals.ownUses !== undefined);
-    totals.coverage = !complete
+    /**
+     * `0 DE 0` NÃO É NOTA MÁXIMA - a mesma correção que a régua recebeu em 12/09 (ver `Reach` em
+     * `doctor/scan.ts`). Fundir dois escopos sem um único valor de design devolvia `100`, e o campo
+     * agora some: quem lê distingue "nada veio do sistema" de "não havia o que contar".
+     */
+    const share = !complete
         ? first.totals.coverage
         : denominator > 0
             ? Math.round((named / denominator) * 100)
-            : 100;
+            : undefined;
+    if (share === undefined)
+        delete totals.coverage;
+    else
+        totals.coverage = share;
     const out = {
         ...first,
         project: { ...first.project, stack },

package/dist/outside-scope.js

@@ -1,4 +1,4 @@
-import { readdir } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import { join, relative, sep } from "node:path";
 /**
  * O QUE O ESCOPO EXCLUIU - o único denominador que a esteira não tinha.
@@ -78,11 +78,26 @@ async function countIn(dir, root, inside, tally, depth = 0) {
  * escopo" não é uma categoria que existe - e emitir uma linha de zero ensinaria o cliente a ignorar a
  * seção quando ela tiver algo.
  */
-export async function outsideScope(root, scopes) {
-    const declared = scopes.map((s) => s.replace(/^\.\//, "").replace(/\/$/, ""));
+export async function outsideScope(root, scopes, 
+/**
+ * QUEM MAIS ESTÁ GOVERNADO, e quem ele tirou.
+ *
+ * Os dois vêm MEDIDOS ou DECLARADOS, nunca supostos: `consumers` é `census.adoption.consumers`,
+ * que a esteira produz ao ver quem importa a biblioteca; `ungoverned` é a lista que ELE escreveu
+ * em `_synthesisui/config.json`. Sem os dois, esta função responde exatamente o que respondia
+ * antes de a governança existir.
+ */
+also = {}) {
+    const clean = (s) => s.replace(/^\.\//, "").replace(/\/$/, "");
+    const declared = scopes.map(clean);
     if (declared.length === 0)
         return null;
-    const inside = (rel) => declared.some((s) => rel === s || rel.startsWith(`${s}/`));
+    const out = (also.ungoverned ?? []).map(clean);
+    const isOut = (rel) => out.some((s) => rel === s || rel.startsWith(`${s}/`));
+    /** Um consumidor que ele declarou fora volta a ser fora - a saída é dele. */
+    const consumers = (also.consumers ?? []).map(clean).filter((c) => !isOut(c));
+    const under = (paths, rel) => paths.some((s) => rel === s || rel.startsWith(`${s}/`));
+    const inside = (rel) => under(declared, rel);
     const tally = new Map();
     await countIn(root, root, inside, tally);
     const places = [...tally]
@@ -91,6 +106,20 @@ export async function outsideScope(root, scopes) {
     const files = places.reduce((n, p) => n + p.files, 0);
     if (files === 0)
         return null;
+    /**
+     * A GOVERNANÇA É UM CAMPO AO LADO, e NUNCA um desconto nesta conta - achado da revisão de
+     * contrato no fecho, e ele estava certo pelo motivo exato.
+     *
+     * A primeira versão tirava os consumidores de `files`/`places`, e isso misturava duas réguas num
+     * número só: um app que ninguém APONTOU continua não tendo sido LIDO, e esta conta existe para
+     * dizer o tamanho da porta fechada. Descontá-lo aqui fazia 26 arquivos de um repositório real
+     * saírem do denominador sem uma linha deles ter sido aberta - o oposto do que o cabeçalho
+     * promete.
+     *
+     * A separação é por LUGAR porque a unidade da frase é o lugar: `apps/landing` é o que ele
+     * reconhece, e `countIn` já agrupa por diretório de topo.
+     */
+    const governed = places.filter((p) => under(consumers, p.path));
     const named = places
         .slice(0, 3)
         .map((p) => `${p.path} (${p.files})`)
@@ -98,6 +127,73 @@ export async function outsideScope(root, scopes) {
     return {
         files,
         places,
+        governed,
+        /** A frase é só sobre LEITURA - a da governança mora em `guarantee.ts`, e é outra régua. */
         said: `${files} more readable file${files === 1 ? "" : "s"} live outside what you pointed at - ${named}${places.length > 3 ? `, and ${places.length - 3} more place${places.length - 3 === 1 ? "" : "s"}` : ""}. Nothing was read there, so nothing about them is in this measurement: point at them too if their design belongs in this system.`,
     };
 }
+/**
+ * QUEM DEPENDE DESTA BIBLIOTECA, lido do arquivo em que o próprio gerenciador de pacotes decide.
+ *
+ * ═══ O QUE ISTO DESTRAVA ═══
+ *
+ * Os apps que consomem a biblioteca passam a estar governados SEM ninguém digitar um `--usage`.
+ * Medido em 12/09 no `codelevel`: o censo conhecia `apps/landing` e `apps/web` porque alguém os
+ * apontou à mão; num repositório onde ninguém apontou, os dois lugares onde a tela é escrita
+ * ficavam do lado de fora da garantia, ao lado de `packages/cli` e `packages/db`.
+ *
+ * ═══ POR QUE `package.json`, E NÃO UMA VARREDURA DE IMPORTS ═══
+ *
+ * Um app que escreve `import { Card } from "@repo/ui"` é um consumidor, e descobrir isso lendo
+ * todo arquivo do repositório custa a varredura inteira. O `package.json` dele já declara a
+ * dependência - é o que o gerenciador de pacotes lê para instalar -, e uma dependência declarada é
+ * evidência mais forte que uma string encontrada: ela é a intenção, não o rastro.
+ *
+ * O QUE ISTO NÃO ALCANÇA, declarado: um repositório de um pacote só, sem workspaces, não tem um
+ * segundo `package.json` para ler - e ali não há "consumidor" separado a governar, porque o escopo
+ * medido e o app são o mesmo lugar.
+ */
+export async function consumersOf(root, specifier) {
+    if (!specifier)
+        return [];
+    const found = [];
+    const visit = async (dir, depth) => {
+        if (depth > 3)
+            return;
+        let entries;
+        try {
+            entries = await readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (entry.name.startsWith(".") || SKIP.has(entry.name))
+                continue;
+            if (!entry.isDirectory())
+                continue;
+            const here = join(dir, entry.name);
+            const raw = await readFile(join(here, "package.json"), "utf8").catch(() => "");
+            if (raw) {
+                try {
+                    const pkg = JSON.parse(raw);
+                    const deps = ["dependencies", "devDependencies", "peerDependencies"]
+                        .map((k) => pkg[k])
+                        .filter((d) => !!d && typeof d === "object");
+                    if (deps.some((d) => specifier in d)) {
+                        const rel = relative(root, here);
+                        /** O próprio pacote não é consumidor de si mesmo. */
+                        if (rel && pkg.name !== specifier)
+                            found.push(rel);
+                    }
+                }
+                catch {
+                    // Um `package.json` ilegível custa a descoberta daquele lugar, nunca a rodada.
+                }
+            }
+            await visit(here, depth + 1);
+        }
+    };
+    await visit(root, 0);
+    return found.sort();
+}

package/dist/rule-touched.js

@@ -1,40 +1,6 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 const run = promisify(execFile);
-/**
- * O QUE ESTA EDIÇÃO APAGOU, E QUAL REGRA DELE ISSO TOCA.
- *
- * ═══ O CASO, medido em 12/09 ═══
- *
- * O agente dele apagou a serif itálica de seis lugares da landing do `codelevel`. A regra existia,
- * instalada: *"A display headline breaks onto a line set in the serif, italic - that line carries
- * the emphasis of the sentence, never the whole headline."* Nada avisou.
- *
- * Duas razões, e este arquivo é as duas. A checagem lia o ARQUIVO depois da escrita - e uma
- * remoção é, por construção, aquilo que não está mais lá. E ela media VALOR SOLTO contra token,
- * nunca regra.
- *
- * ═══ O ANTES VEM DO GIT, e não do payload do cliente ═══
- *
- * O hook recebe `tool_input.file_path` e o cliente PODE mandar o texto anterior - mas o formato é
- * de cada cliente, muda entre versões, e um produto que se apoia nele funciona num editor e cala
- * no seguinte. O git é o mesmo em todo lugar e responde a pergunta certa: *o que esta árvore
- * removeu em relação ao último commit?* - que é exatamente o que ele vai empurrar.
- *
- * SEM GIT, SEM ARQUIVO NO HEAD, OU ARQUIVO NOVO: não há "antes", então não há remoção. Silêncio é
- * a resposta correta, e não uma falha - um arquivo novo não apagou nada de ninguém.
- *
- * ═══ E O CASAMENTO É POR VOCABULÁRIO DECLARADO, nunca por palavra em inglês ═══
- *
- * A tentação é procurar as palavras da regra no diff. Isso casaria *"never"* com qualquer coisa e
- * transformaria a checagem numa fonte de falso positivo - e um falso positivo custa mais que
- * silêncio aqui, porque ele treina a pessoa a ignorar a saída e depois a desinstalar o hook.
- *
- * Então os dois lados são amarrados pelo que o SISTEMA DELE DECLARA. Uma regra "toca" o que foi
- * apagado quando um nome declarado aparece nos dois: no texto da regra e no que saiu do arquivo.
- * No caso real: o sistema declara `--font-serif`, a regra fala em `serif`, e a edição removeu
- * `font-serif` seis vezes.
- */
 /** Como o texto anterior era, ou `null` quando não há "antes" que se possa provar. */
 export async function previousText(root, rel) {
     try {
@@ -78,11 +44,20 @@ export async function previousText(root, rel) {
  * arquivo. É a troca certa. A regra fala sobre o sistema ter aquela decisão presente, e um uso que
  * fica mantém a decisão presente; acusar por contagem transformaria toda refatoração num alarme.
  */
-export function namesRemoved(before, after, declared) {
-    const had = declaredNamesIn(before, declared);
+export function namesRemoved(before, after, 
+/**
+ * A TABELA INTEIRA, e não o conjunto de nomes - porta fechada em vez de vigiada.
+ *
+ * Ela era `declared: ReadonlySet<string>`, e quando a leitura por idioma entrou o chamador
+ * passaria a precisar de um segundo argumento. Um argumento a mais é um argumento esquecido: o
+ * comando leria as utilities dele e o hook não, e o mesmo repositório receberia duas respostas
+ * sobre a mesma regra.
+ */
+table) {
+    const had = declaredNamesIn(before, table);
     if (had.length === 0)
         return [];
-    const kept = new Set(declaredNamesIn(after, declared));
+    const kept = new Set(declaredNamesIn(after, table));
     return had.filter((name) => !kept.has(name));
 }
 /**
@@ -124,13 +99,28 @@ const mentions = (text, word) => new RegExp(`(^|[^a-z0-9-])${word}([^a-z0-9-]|$)
  * `--font-serif` cru numa declaração, e `font-serif` como utility - que é o idioma medido em 72%
  * dos `.tsx` dele. Sem a terceira, um repositório Tailwind inteiro não referenciaria nada.
  */
-export function declaredNamesIn(text, declared) {
+export function declaredNamesIn(text, { declared, utilities }) {
     const found = new Set();
     for (const name of declared) {
         const bare = name.replace(/^--/, "");
         if (text.includes(name) || mentions(text, bare))
             found.add(name);
     }
+    /**
+     * E A QUARTA FORMA, que era a maior lacuna - a utility que o idioma dele RENOMEIA.
+     *
+     * As três acima só fecham onde o nome do token É a string escrita (`--font-serif` →
+     * `font-serif`). Onde o compilador renomeia - `--color-primary` → `bg-primary`,
+     * `--spacing-6` → `p-6` - nada casava, e medido em 12/09 na população viva: **5 das 25 regras
+     * dele eram alcançadas**, todas por `--font-*`, `--animate-*`, `--ease-*`, `--shadow-sm`,
+     * `--text-sm`. Zero cor, zero espaçamento, zero raio - que é a maior classe de regra de qualquer
+     * design system.
+     *
+     * O índice sai do que ELE declarou, pelo contrato do framework - ver `idiom-names.ts`.
+     */
+    for (const [spelling, name] of utilities)
+        if (mentions(text, spelling))
+            found.add(name);
     return [...found];
 }
 /** A regra escreve este nome - por inteiro, ou pela folha dele. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "synthesisui",
-  "version": "0.16.419",
+  "version": "0.16.421",
   "description": "Bring SynthesisUI design systems into any project - tokens, typed components, whole pages and an agent-ready CLAUDE.md manifest.",
   "type": "module",
   "bin": {