synthesisui 0.16.134 → 0.16.136

package/dist/commands/gaps.js

@@ -0,0 +1,47 @@
+/**
+ * `synthesisui gaps` - o que esta esteira NÃO leu do projeto, triado.
+ *
+ * O `import` já imprime o ledger no fim de uma execução, e é ali que a pessoa o vê uma vez. Depois
+ * disso o número fica em `_synthesisui/census.json` e não existe pergunta que se possa fazer a ele:
+ * "quanto disso é trabalho de vocês?" não tinha resposta em lugar nenhum, e sem ela o ciclo de
+ * conserto continua dependendo de alguém reportar (dono, 05/08).
+ *
+ * Não mede nada: lê o censo em disco. Medir aqui seria uma segunda leitura dos arquivos deles, com
+ * uma segunda chance de discordar do que a receita diz.
+ *
+ * E o texto que ele imprime é o que a pessoa manda para quem vai escrever o leitor - por isso ele
+ * nomeia o módulo e nunca sugere código.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { describeTriage, triageLedger } from "../doctor/gap-triage.js";
+import { body, section } from "../output.js";
+export async function gaps(opts) {
+    const root = opts.dir ?? process.cwd();
+    const path = opts.census ?? join(root, "_synthesisui", "census.json");
+    const raw = await readFile(path, "utf8").catch(() => null);
+    console.log(section("What this pipeline did not read"));
+    if (!raw) {
+        console.log(body(`No census at ${path}. Run \`synthesisui import --dry\` first - that is what measures your files, and it writes the census there.`));
+        return;
+    }
+    let ledger;
+    try {
+        ledger = JSON.parse(raw).ledger;
+    }
+    catch {
+        console.log(body(`${path} is not readable JSON.`));
+        return;
+    }
+    /**
+     * UM CENSO SEM LEDGER NÃO É UM PROJETO SEM LACUNA. Ele foi medido por uma versão que não
+     * contabilizava, e dizer "0 gaps" aqui seria a mentira mais barata que este comando poderia
+     * contar.
+     */
+    if (!ledger) {
+        console.log(body(`This census was written by a CLI that did not count style fragments yet, so the numbers do not exist rather than being zero. Run \`synthesisui import --dry\` again with ${opts.cli} to measure.`));
+        return;
+    }
+    for (const line of describeTriage(triageLedger(ledger, opts.cli)))
+        console.log(body(line));
+}

package/dist/commands/import.js

@@ -13,7 +13,7 @@ import { describeGate, gateComponent, groupSkips, SCREENS_FOR_SYSTEM, } from "..
 import { emptyTally, internalSpecifiers, scanComponentsInto, tallyToInventory, } from "../doctor/components-scan.js";
 import { countShape, describeCoverage, summarizeCoverage, } from "../doctor/coverage.js";
 import { crosswalk, floorSize, isLibrary, observedRules, useLiveCatalogue, } from "../doctor/crosswalk.js";
-import { keyframeOffsets, moduleImports, readModuleCss, readModuleUsage, transcribeModule, } from "../doctor/css-modules.js";
+import { keyframeOffsets, moduleImports, partialCandidates, readModuleCss, readModuleUsage, sheetImports, transcribeModule, } from "../doctor/css-modules.js";
 import { dataContract } from "../doctor/data-contract.js";
 import { reconcile, scanDefinitions, } from "../doctor/definitions-scan.js";
 import { fragmentsOfSource, fragmentsOfStylesheet, judgeFragments, } from "../doctor/fragments.js";
@@ -128,6 +128,48 @@ async function siblingProjects(root) {
  * this" - could not be said, and we ended up rediscovering by colour distance
  * what their stylesheet had spelled out all along.
  */
+/**
+ * UMA FOLHA E TUDO O QUE ELA TRAZ PARA DENTRO DE SI, na ordem em que o sass compila.
+ *
+ * Uma partial (`_darkMode.scss`) nunca é compilada sozinha: ela entra em quem a importa, e portanto
+ * herda o escopo de quem a importa. Ler o `.module.scss` sem seguir os `@import` dele deixava de
+ * fora 1 400 declarações (91% de tudo o que a esteira chamava de "CSS global sem leitor") - e elas
+ * são, no build dele, as faces light e dark de classes que o componente JÁ veste (medido, 05/08).
+ *
+ * Devolve o CSS concatenado e os arquivos que entraram, porque o ledger precisa saber que a partial
+ * pertence a um componente admitido - senão ela continua contabilizada como forma sem leitor, e o
+ * relatório passa a discordar da receita.
+ */
+async function sheetWithImports(path, seen = new Set(), depth = 0) {
+    if (depth > 6 || seen.has(path))
+        return { css: "", files: [] };
+    seen.add(path);
+    const body = await readFile(path, "utf8").catch(() => "");
+    if (!body)
+        return { css: "", files: [] };
+    let css = "";
+    const files = [path];
+    /**
+     * O IMPORTADO VEM ANTES, que é a ordem do sass: quem importa sobrescreve o que importou. Inverter
+     * isto faria a face dark de uma partial vencer a base do próprio module.
+     */
+    for (const spec of sheetImports(body)) {
+        for (const candidate of partialCandidates(spec)) {
+            const child = join(dirname(path), candidate);
+            const nested = await sheetWithImports(child, seen, depth + 1);
+            if (nested.css || nested.files.length > 1 || (await exists(child))) {
+                css += nested.css;
+                files.push(...nested.files);
+                break;
+            }
+        }
+    }
+    return { css: `${css}\n${body}`, files };
+}
+/** Existe no disco - o candidato de partial que o sass acharia primeiro. */
+async function exists(path) {
+    return await readFile(path, "utf8").then(() => true, () => false);
+}
 async function harvestOwnCss(root, 
 /**
  * O LEDGER TAMBÉM COME AQUI, e por um motivo de promessa: este é o único laço que vê TODO
@@ -139,17 +181,40 @@ async function harvestOwnCss(root,
  * não admitido é um motivo, não um desaparecimento.
  */
 into) {
-    let css = "";
+    /**
+     * DOIS PASSES, porque o escopo de uma folha está no GRAFO e não no nome dela.
+     *
+     * O primeiro junta tudo; o segundo julga cada folha sabendo quem importa quem. Um pass só
+     * decidia por `/\.module\./` e chamava de "CSS global sem leitor" 1 400 declarações que o build
+     * deles compila dentro de um module (medido, 05/08).
+     */
+    const sheets = [];
     for await (const file of walkAll([root])) {
         if (!/\.(css|scss|sass|less)$/i.test(file))
             continue;
         const body = await readFile(file, "utf8").catch(() => "");
+        sheets.push({ file, body });
+    }
+    /** Todo caminho que alguma folha importa, resolvido como o sass resolveria. */
+    const imported = new Set();
+    for (const sheet of sheets)
+        for (const spec of sheetImports(sheet.body))
+            for (const candidate of partialCandidates(spec))
+                imported.add(join(dirname(sheet.file), candidate));
+    let css = "";
+    for (const { file, body } of sheets) {
         css += `\n${body}`;
-        if (into && body)
-            into.push({
-                file: relative(root, file),
-                fragments: fragmentsOfStylesheet(relative(root, file), body, /\.module\./.test(file)),
-            });
+        if (!into || !body)
+            continue;
+        const partial = basename(file).startsWith("_");
+        into.push({
+            file: relative(root, file),
+            fragments: fragmentsOfStylesheet(relative(root, file), body, /\.module\./.test(file) || (partial && imported.has(file))
+                ? "scoped"
+                : partial
+                    ? "dead"
+                    : "global"),
+        });
     }
     return css;
 }
@@ -564,7 +629,13 @@ export async function takeCensus(root, opts) {
                 let fromModule = null;
                 for (const mod of modules) {
                     const cssPath = join(dirname(file), mod.specifier);
-                    const moduleCss = await readFile(cssPath, "utf8").catch(() => "");
+                    /**
+                     * O MODULE E AS PARTIALS QUE ELE IMPORTA, que no build dele são um arquivo só. Ler apenas
+                     * o `.module.scss` deixava 1 400 declarações fora - as faces light e dark de classes que
+                     * o componente já veste, escritas em `_lightMode.scss`/`_darkMode.scss` ao lado.
+                     */
+                    const sheet = await sheetWithImports(cssPath);
+                    const moduleCss = sheet.css.trim();
                     if (!moduleCss)
                         continue;
                     const usage = readModuleUsage(src, mod.local);
@@ -574,8 +645,14 @@ export async function takeCensus(root, opts) {
                      * ESTE MODULE PERTENCE A UM COMPONENTE ADMITIDO - o único fato que este laço tem e o
                      * ledger precisa. Os fragmentos dele vêm do `harvestOwnCss`, que vê todos os arquivos
                      * de estilo e não só os de componente aceito.
+                     *
+                     * A PARTIAL ENTRA JUNTO: ela é parte deste module, então o veredito dela é o mesmo. Sem
+                     * isto o relatório continuaria chamando de "forma sem leitor" exatamente o que a receita
+                     * acabou de ler - relatório e receita discordando, que é o defeito que o ledger existe
+                     * para não ter.
                      */
-                    admittedStyles.add(relative(root, cssPath));
+                    for (const part of sheet.files)
+                        admittedStyles.add(relative(root, part));
                     const readModule = transcribeModule(readModuleCss(moduleCss), usage, declaredValues);
                     if (readModule.read === 0)
                         continue;

package/dist/doctor/css-modules.js

@@ -335,6 +335,50 @@ export function moduleImports(source) {
         specifier: m[2],
     }));
 }
+/**
+ * `@import "./_darkMode"`, `@use "./_lightMode.scss"` - o que uma folha traz para dentro de si.
+ *
+ * UMA PARTIAL NÃO É UMA FOLHA. Um arquivo `_nome.scss` nunca é compilado sozinho - o sass o
+ * compila DENTRO de quem o importa, e por isso o escopo dele é o de quem importa. No app do dono,
+ * 122 das 138 folhas "globais" são partials e 120 delas são importadas por um `.module.scss` do
+ * mesmo diretório: 1 400 declarações (91%) que a esteira classificava como CSS global sem leitor
+ * são, no build dele, regras de module - hasheadas e escopadas ao componente (medido, 05/08).
+ *
+ * Decidir escopo por NOME DE ARQUIVO (`/\.module\./`) é a lei 14 um nível abaixo: a resposta está
+ * no grafo de imports, não na string do caminho.
+ */
+const SHEET_IMPORT = /@(?:import|use|forward)\s+["']([^"']+)["']/g;
+export function sheetImports(css) {
+    SHEET_IMPORT.lastIndex = 0;
+    return ([...stripCssComments(css).matchAll(SHEET_IMPORT)]
+        .map((m) => m[1].trim())
+        /**
+         * Só o que é relativo. `@use "sass:math"` e um pacote do node_modules não carregam decisão de
+         * aparência deles, e seguir esses caminhos é como um leitor de CSS vira um resolvedor de
+         * módulos pela metade.
+         */
+        .filter((spec) => spec.startsWith(".") || !spec.includes(":"))
+        .filter((spec) => !spec.startsWith("~") && !spec.startsWith("url(")));
+}
+/** `./_darkMode` → os nomes de arquivo que o sass tentaria, na ordem em que ele tenta. */
+export function partialCandidates(specifier) {
+    const clean = specifier.replace(/^\.\//, "");
+    const slash = clean.lastIndexOf("/");
+    const dir = slash === -1 ? "" : `${clean.slice(0, slash)}/`;
+    const base = slash === -1 ? clean : clean.slice(slash + 1);
+    if (/\.(css|scss|sass|less)$/.test(base))
+        return base.startsWith("_")
+            ? [`${dir}${base}`]
+            : [`${dir}${base}`, `${dir}_${base}`];
+    const stem = base.startsWith("_") ? base : `_${base}`;
+    return [
+        `${dir}${base}.scss`,
+        `${dir}${stem}.scss`,
+        `${dir}${base}.sass`,
+        `${dir}${stem}.sass`,
+        `${dir}${base}.css`,
+    ];
+}
 /**
  * A generic in type position, not an element.
  *

package/dist/doctor/fragments.js

@@ -110,7 +110,20 @@ export function fragmentsOfSource(file, source) {
  * contagem: um global com regra de CLASSE é forma que nenhum leitor cobre hoje - 399 declarações
  * no repo dele, e a única lacuna que estava calada em vez de declarada (04/08).
  */
-export function fragmentsOfStylesheet(file, css, scoped) {
+export function fragmentsOfStylesheet(file, css, 
+/**
+ * COMO ESTA FOLHA CHEGA NO BUILD DELES, e isso vem do GRAFO DE IMPORTS e nunca do nome do
+ * arquivo. Uma partial (`_darkMode.scss`) é compilada dentro de quem a importa e herda o escopo
+ * dele: 122 das 138 folhas "globais" do app dele são partials, e 120 entram num `.module.scss`
+ * ao lado (medido, 05/08).
+ *
+ *     scoped   module, ou partial de um module: o veredito é do componente dono, e
+ *              `judgeFragments` o dá olhando se o escopo o admitiu
+ *     global   uma folha que o código importa: forma que nenhum leitor cobre hoje
+ *     dead     partial que ninguém importa: o build deles não a compila, e ela não
+ *              pinta nada - aqui, nem lá
+ */
+kind) {
     const out = [];
     let selector = "";
     for (const [i, raw] of css.split("\n").entries()) {
@@ -143,7 +156,11 @@ export function fragmentsOfStylesheet(file, css, scoped) {
                 line: i + 1,
                 text: `${selector ? `${selector} ` : ""}{ ${m[1]}: ${m[2].trim()} }`,
                 read: false,
-                ...(scoped ? {} : { reason: "shape-not-read" }),
+                ...(kind === "global"
+                    ? { reason: "shape-not-read" }
+                    : kind === "dead"
+                        ? { reason: "sheet-not-imported" }
+                        : {}),
             });
         }
     }

package/dist/doctor/gap-triage.js

@@ -0,0 +1,193 @@
+/**
+ * O QUE FAZER COM O QUE NÃO FOI LIDO - triado, e nem tudo é trabalho.
+ *
+ * O ledger diz quanto e onde. Essa é metade da resposta, e sozinha ela ENGANA: no dashboard do
+ * dono, 6 610 dos 8 523 fragmentos não interpretados (78%) não são lacuna de leitura nenhuma - são
+ * o portão recusando um componente e classe montada em tempo de execução. Uma pessoa olhando "56%
+ * interpretado" conclui que falta ler 44% do app e vai escrever o leitor errado (medido, 04/08).
+ *
+ * ENTÃO A TRIAGEM É ESTA, e a ordem dela é a ordem em que alguém decide:
+ *
+ *     older-cli    medido por uma versão antiga. Re-medir ANTES de qualquer conclusão -
+ *                  a lacuna pode já estar fechada e o trabalho já estar feito.
+ *     no-reader    nenhum leitor entende esta forma. É trabalho, e o módulo é nomeado.
+ *     value-gap    a forma é lida e o VALOR não. O trabalho é nas tabelas de escala,
+ *                  não num leitor novo - confundir os dois custa um módulo inteiro.
+ *     by-design    o portão recusou, ou o valor não existe na fonte. NÃO É LACUNA, e a
+ *                  triagem para aqui em vez de mandar alguém consertar o que não quebrou.
+ *
+ * O QUE ELA NUNCA FAZ: sugerir código. Ela nomeia o módulo onde o leitor mora ou moraria, e a
+ * decisão de escrever é de quem lê - a esteira opinando sobre o nosso backlog no terminal do
+ * cliente é ela falando de um assunto que não é dela (dono, 05/08).
+ */
+/**
+ * QUEM É DONO DE CADA FORMA, hoje.
+ *
+ * Nomear o módulo é a diferença entre "isto não é lido" e "isto é trabalho aqui". A forma que não
+ * tem dono ganha `null`, e um leitor novo é um módulo novo - dizer que ele "vai em transcribe"
+ * quando não vai é pior que não dizer nada.
+ */
+const OWNER = {
+    class: "src/doctor/transcribe.ts",
+    template: "src/doctor/sketch.ts (the literal halves) + src/doctor/variant-read.ts",
+    inline: "src/doctor/transcribe.ts (readInlineStyle)",
+    css: "src/doctor/css-modules.ts",
+    sx: null,
+    styled: null,
+    runtime: null,
+};
+/**
+ * O motivo decide o veredito, nunca a forma.
+ *
+ * `css` aparece nos dois lados: uma declaração de module de componente admitido é LIDA, a mesma
+ * declaração num `.css` global não tem leitor, e a de um componente que o portão não admite está
+ * lida e sem receita que a reivindique. Três destinos, uma forma - por isso o veredito lê o motivo.
+ */
+function verdictOf(reason) {
+    switch (reason) {
+        case "shape-not-read":
+            return "no-reader";
+        case "value-not-read":
+            return "value-gap";
+        default:
+            // `computed` e `component-not-admitted`: nenhum leitor muda o resultado.
+            return "by-design";
+    }
+}
+/** Onde o trabalho mora, para cada veredito - ou por que não existe trabalho. */
+function whereOf(shape, reason) {
+    switch (verdictOf(reason)) {
+        case "no-reader": {
+            /**
+             * A REGRA DE CLASSE NUM CSS GLOBAL é a lacuna de leitura mais barata que existe hoje no
+             * repo do dono - 1 520 declarações em 135 arquivos - e ela não tem dono: `css-modules.ts` lê
+             * o module (escopo garantido pelo bundler), e um global vale para toda a página.
+             */
+            const owner = shape === "css" ? null : OWNER[shape];
+            return owner
+                ? {
+                    module: owner,
+                    work: `a reader exists and does not cover this shape: ${owner}`,
+                }
+                : {
+                    module: null,
+                    work: "no module owns this shape - a reader here is a new module, and it needs an app in the corpus before it exists",
+                };
+        }
+        case "value-gap":
+            return {
+                module: "src/doctor/transcribe.ts",
+                work: "the shape is already read; what is missing is a SCALE that recognises this value - a table, not a new reader",
+            };
+        default:
+            return {
+                module: null,
+                work: reason === "component-not-admitted"
+                    ? "the gate refused the component: these styles exist and no recipe claims them. Changing that means moving the GATE - a decision about the vitrine, not a reader to write"
+                    : reason === "sheet-not-imported"
+                        ? /**
+                           * NÃO É LACUNA NOSSA NEM DELES-QUE-A-GENTE-CONSERTA: é um arquivo que o build deles
+                           * não compila. Cair na frase de runtime dizia que o valor é montado em tempo de
+                           * execução, o que é falso e mandaria alguém procurar o que não existe.
+                           */
+                            "a sass partial no stylesheet imports: their own build never compiles it, so it paints nothing today - here or in their app. Deleting it is their call, not a reader to write"
+                        : "the value is assembled at render time and is not in the source at any level - there is nothing to read",
+            };
+    }
+}
+/**
+ * A triagem de um ledger, contra a versão que está triando.
+ *
+ * Pura: ninguém abre arquivo aqui. O ledger já carrega tudo - inclusive a versão que o mediu, que
+ * é o campo sem o qual esta função não teria como responder a primeira pergunta.
+ */
+export function triageLedger(ledger, triagedBy) {
+    const sum = (counts) => Object.values(counts).reduce((n, k) => n + k, 0);
+    const counted = sum(ledger.counted);
+    const interpreted = sum(ledger.interpreted);
+    const unread = counted - interpreted;
+    const totals = { "no-reader": 0, "value-gap": 0, "by-design": 0 };
+    const rank = {
+        "no-reader": 0,
+        "value-gap": 1,
+        "by-design": 2,
+    };
+    const gaps = ledger.unread.map((group) => {
+        const verdict = verdictOf(group.reason);
+        totals[verdict] += group.uses;
+        const { module, work } = whereOf(group.shape, group.reason);
+        return {
+            shape: group.shape,
+            reason: group.reason,
+            verdict,
+            uses: group.uses,
+            files: group.files,
+            share: unread > 0 ? Math.round((group.uses / unread) * 100) : 0,
+            module,
+            work,
+            because: group.because,
+            examples: group.examples,
+        };
+    });
+    gaps.sort((a, b) => rank[a.verdict] - rank[b.verdict] || b.uses - a.uses);
+    return {
+        measuredBy: ledger.cli,
+        triagedBy,
+        stale: isOlder(ledger.cli, triagedBy),
+        counted,
+        interpreted,
+        percent: counted > 0 ? Math.round((interpreted / counted) * 100) : 0,
+        totals,
+        gaps,
+    };
+}
+/** `0.16.133` é mais velha que `0.16.134`. Compara número por número, e o que não é número não
+ *  desempata nada - uma pré-release não é motivo para dizer que a medição está velha. */
+function isOlder(measured, current) {
+    const parts = (v) => v.split(".").map((p) => Number.parseInt(p, 10));
+    const a = parts(measured);
+    const b = parts(current);
+    for (let i = 0; i < Math.max(a.length, b.length); i += 1) {
+        const left = a[i];
+        const right = b[i];
+        if (!Number.isFinite(left) || !Number.isFinite(right))
+            return false;
+        if (left !== right)
+            return left < right;
+    }
+    return false;
+}
+/**
+ * A triagem em texto, na ordem em que uma pessoa decide.
+ *
+ * Lidera pelo que NÃO é trabalho quando ele domina, porque é o número que muda a conclusão: 78%
+ * do não interpretado ser o portão funcionando é a informação mais importante da tela, e ela vem
+ * antes de qualquer lista de tarefa.
+ */
+export function describeTriage(t) {
+    const unread = t.counted - t.interpreted;
+    const lines = [
+        `${t.counted} style fragments accounted for, ${t.interpreted} interpreted (${t.percent}%). The ${unread} below are sorted by what to do about them.`,
+    ];
+    if (t.stale) {
+        lines.push("", `MEASURED BY CLI ${t.measuredBy}, TRIAGED BY ${t.triagedBy}. Re-run \`import\` before concluding anything from the numbers below - a gap here may already be closed, and the work already done.`);
+    }
+    const label = {
+        "no-reader": "NO READER FOR THIS SHAPE - this is work",
+        "value-gap": "THE SHAPE IS READ, THE VALUE IS NOT - a scale, not a reader",
+        "by-design": "NOT A READING GAP - nothing a reader would change, and no work here",
+    };
+    for (const verdict of ["no-reader", "value-gap", "by-design"]) {
+        const group = t.gaps.filter((g) => g.verdict === verdict);
+        if (group.length === 0)
+            continue;
+        const total = t.totals[verdict];
+        lines.push("", `${label[verdict]} - ${total} fragment${total === 1 ? "" : "s"}, ${unread > 0 ? Math.round((total / unread) * 100) : 0}% of what was not interpreted`);
+        for (const gap of group) {
+            lines.push(`  ${gap.uses} ${gap.shape} in ${gap.files} file${gap.files === 1 ? "" : "s"} (${gap.share}%) - ${gap.work}`);
+            for (const example of gap.examples.slice(0, 2))
+                lines.push(`      ${example.file}:${example.line}  ${example.text.slice(0, 76)}`);
+        }
+    }
+    return lines;
+}

package/dist/doctor/style-ledger.js

@@ -54,6 +54,7 @@ const BECAUSE = {
     "value-not-read": "the shape is read and this value is not - a utility or property outside the scales this project declares",
     computed: "the value is assembled at render time, so it is not in the source at any level and there is nothing to read",
     "component-not-admitted": "read, and it belongs to a component this scope does not admit into the system - the styles exist and no recipe claims them",
+    "sheet-not-imported": "this is a sass partial and no stylesheet imports it, so your own build never compiles it - it paints nothing today, here or anywhere",
 };
 /**
  * O ledger de uma varredura, a partir dos fragmentos vistos.

package/dist/index.js

@@ -7,6 +7,7 @@ import { clean } from "./commands/clean.js";
 import { component } from "./commands/component.js";
 import { connect } from "./commands/connect.js";
 import { doctor } from "./commands/doctor.js";
+import { gaps } from "./commands/gaps.js";
 import { generate } from "./commands/generate.js";
 import { hook } from "./commands/hook.js";
 import { runImport } from "./commands/import.js";
@@ -48,6 +49,9 @@ Usage - governance (deterministic, FREE):
   synthesisui doctor [paths…] [--verbose]  audit for DRIFT: every design value written by hand, the
                                            token your system already has for it, coherence, and the
                                            record over time
+  synthesisui gaps [--census <p>]           what this pipeline did NOT read of your project, triaged:
+                                           a reader that is missing, a value outside your scales, or
+                                           something no reader would change
   synthesisui request [component|token]    the queue of what your agent needed and the system
                                            refused to invent (--done <id> closes one)
   synthesisui sync                         send the local record - checks, fixes, open requests -
@@ -247,6 +251,21 @@ async function main() {
                 laws: flags.laws === true,
             });
             break;
+        case "gaps":
+            /**
+             * O LEDGER JÁ ESTÁ NO CENSO - isto não mede nada, tria.
+             *
+             * Existe para que a triagem seja alcançável por uma pessoa, e não só pelo spec: quem rodou
+             * `import` uma vez tem o número em disco e nenhuma forma de perguntar "e o que eu faço com
+             * isso". O texto que sai daqui é exatamente o que ele me manda quando quer que eu escreva o
+             * leitor (dono, 05/08).
+             */
+            await gaps({
+                dir,
+                census: typeof flags.census === "string" ? flags.census : undefined,
+                cli: CLI_VERSION,
+            });
+            break;
         case "list":
             await list({ registry });
             break;

package/package.json

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