synthesisui 0.16.222 → 0.16.227

package/dist/commands/doctor.js

@@ -11,6 +11,7 @@ import { findFrozenBindings } from "../doctor/frozen.js";
 import { appendEvent, COVERAGE_RULE, readEvents, suggestionsFrom, summarize, } from "../doctor/ledger.js";
 import { bindingsFromDocument, countComponents, findOverrides, } from "../doctor/overrides.js";
 import { checkableName, readRequests, verifyAndCloseRequests, } from "../doctor/requests.js";
+import { DEFAULT_ROOT_PX, rootSizeOf, saidOfRoot, } from "../doctor/root-size.js";
 import { diagnose, scanSource, siblingTokens, } from "../doctor/scan.js";
 import { findSelfConflicts, forbiddenProps, isReset, propMatchesLabel, } from "../doctor/self-conflict.js";
 import { buildTable, EMPTY_TABLE, nearestToken, } from "../doctor/tokens.js";
@@ -144,7 +145,20 @@ function requestLabel(r) {
         return `rule "${r.name}"`;
     return `component "${r.name}"`;
 }
-export async function loadSystem(root) {
+export async function loadSystem(root, 
+/**
+ * A RAIZ JÁ MEDIDA, quando quem chama já varreu as folhas de estilo.
+ *
+ * O `doctor` mede (ele já anda no repositório inteiro) e passa. O `hook` NÃO mede, e isso é uma
+ * escolha declarada: ele roda depois de cada escrita com orçamento de ~50ms, e varrer css a cada
+ * edição trocaria um relatório instantâneo por um que a pessoa desliga.
+ *
+ * A consequência, dita em voz alta: num projeto que redefine a raiz (`html { font-size: 62.5% }`),
+ * o hook compara px e rem por 16 e deixa de sugerir algumas trocas que o `doctor` sugere. Ele erra
+ * para o lado de oferecer MENOS, nunca de oferecer a troca errada - e o `--fix`, que é quem escreve,
+ * vem sempre do `doctor`.
+ */
+measured) {
     const dsDir = join(root, "_synthesisui", "ds");
     let slugs;
     try {
@@ -262,7 +276,12 @@ export async function loadSystem(root) {
         }
     }
     return {
-        table: buildTable({ css, lock, source: adopted ? "adopted" : "installed" }),
+        table: buildTable({
+            css,
+            lock,
+            source: adopted ? "adopted" : "installed",
+            ...(measured ? { rootPx: measured.px, rootFrom: measured.from } : {}),
+        }),
         recipes,
         documents,
         requires,
@@ -283,6 +302,19 @@ export async function loadSystem(root) {
  * Reads stylesheets only, and only when nothing of ours is installed, so the
  * common path pays nothing for it.
  */
+/** As folhas de estilo dele, para a medição da raiz. Só css - nada de `.tsx`. */
+async function sheetsIn(roots) {
+    const out = [];
+    for await (const file of walkAll(roots)) {
+        if (!/\.(css|scss|sass|less)$/i.test(file))
+            continue;
+        const css = await readFile(file, "utf8").catch(() => "");
+        /** Só carrega adiante o que pode conter a declaração - o resto é peso à toa. */
+        if (/(?:html|:root)[^{]*\{[^}]*font-size/i.test(css))
+            out.push({ file: relative(roots[0] ?? file, file) || file, css });
+    }
+    return out;
+}
 async function harvestOwnTokens(roots) {
     let css = "";
     for await (const file of walkAll(roots)) {
@@ -483,7 +515,18 @@ export async function doctor(opts) {
     const fullRun = (opts.scopes ?? []).length === 0;
     /** A intenção ordena o relatório, e a precedência é flag > config > default. */
     const intent = intentOf(await readProjectConfig(root), opts.intent);
-    const installed = await loadSystem(root);
+    /**
+     * A RAIZ, MEDIDA ANTES DE COMPARAR VALOR NENHUM - ver `rootSizeOf`.
+     *
+     * `4px` e `0.25rem` só são o mesmo valor se alguém disser quantos pixels vale 1rem AQUI, e supor 16
+     * num projeto que escreve `html { font-size: 62.5% }` erraria em todos os lugares de uma vez, com a
+     * confiança de quem acertou. Uma passada barata: só folhas de estilo, e só o bloco `html`/`:root`.
+     */
+    const rootSize = rootSizeOf(await sheetsIn(scopes.length > 0 ? scopes : [root]));
+    const installed = await loadSystem(root, {
+        px: rootSize.ambiguous ? DEFAULT_ROOT_PX : rootSize.px,
+        from: rootSize.from,
+    });
     const { recipes, documents } = installed;
     let table = installed.table;
     // Nothing of ours here does not mean nothing to measure against. Fall back
@@ -614,6 +657,18 @@ export async function doctor(opts) {
         const said = measured.from === "census" ? describeScope(measured) : null;
         console.log(body(said ?? `scope: ${relScopes.join(", ")}`));
     }
+    /**
+     * A RAIZ QUE ESTA RODADA USOU - e ela é impressa SEMPRE, inclusive quando é o padrão.
+     *
+     * Pedido do dono em 13/08: *"analisar antes se tem algo que interfere no size, e deixar registrado
+     * como uma regra que está sendo usada"*. É o que transforma uma suposição nossa num fato que ele
+     * pode conferir: `4px` e `0.25rem` só são o mesmo valor por causa deste número, e ele decide quantas
+     * trocas o comando oferece.
+     *
+     * Impressa mesmo no caso padrão porque é aí que ela é mais fácil de esquecer - e um relatório que só
+     * fala quando é exceção ensina que o silêncio significa "não olhei".
+     */
+    console.log(body(saidOfRoot(rootSize)));
     /**
      * E A INTENÇÃO, em toda rodada, com a data e o jeito de inverter.
      *

package/dist/commands/sync.js

@@ -16,11 +16,26 @@ import { resolveReadParts, siblingProjects, takeCensus } from "./import.js";
  * after `closeRequest` runs here, so the person knows what happened and what
  * (if anything) is theirs to do next.
  */
-export function decisionLine(d, slug) {
+export function decisionLine(d, slug, 
+/** Onde o sistema dele vive - o `publish` mora lá, e sem o endereço a frase manda procurar. */
+base) {
     const note = d.note ? ` - "${d.note}"` : "";
     switch (d.status) {
+        /**
+         * AUTORIZAR ESCREVE O RASCUNHO, e esta linha dizia o contrário.
+         *
+         * `authorPersonalToken` termina em `writeDraft`, e o registry serve a última PUBLICADA - por lei,
+         * desde 29/07: se o rascunho fluísse para o repo, o botão Publish não seguraria nada.
+         *
+         * Então "Get it: upgrade" mandava a pessoa rodar um comando que responde `already at the latest
+         * version` e não traz o token. Ela seguiu a instrução, não recebeu nada, e fica sem saber se
+         * autorizou errado ou se a ferramenta falhou - que é o pior lugar para deixar alguém que acabou
+         * de fazer exatamente o que a gente pediu (dono, 13/08, vendo isso no terminal dele).
+         *
+         * A frase agora nomeia os DOIS passos, na ordem, e o primeiro é dele.
+         */
         case "authored":
-            return `  ✓ ${d.id} authored on the platform${note}. Get it: npx synthesisui@latest upgrade ${slug}`;
+            return `  ✓ ${d.id} authored into your draft${note}. It reaches this repo once you publish${base ? `: ${base}/dashboard/mine/${slug}/publish` : ""}\n      then: npx synthesisui@latest upgrade ${slug}`;
         case "declined":
             return `  ✕ ${d.id} declined${note}. Now a RULE of the system - it travels with the next upgrade, and agents obey it.`;
         case "platform":
@@ -150,7 +165,7 @@ export async function sync(opts) {
         console.log(body("Answered on the platform, closed here:"));
         for (const d of decisions) {
             await closeRequest(root, d.id);
-            console.log(body(decisionLine(d, slug)));
+            console.log(body(decisionLine(d, slug, base)));
         }
     }
     console.log("");
@@ -276,6 +291,64 @@ export async function remeasure(args) {
     if (stored.reading)
         census.reading = stored.reading;
     await resolveReadParts(census, root, !args.full).catch(() => { });
+    /**
+     * O QUE A RE-MEDIÇÃO NÃO MEDE, ELA NÃO PODE APAGAR - e apagava quatro campos de uma vez.
+     *
+     * O `sync` mede o CÓDIGO dele de novo. Ele não mede polaridade, não pergunta escopo e não refaz a
+     * leitura do agente: esses três são respostas que alguém já deu, e `runImport` é quem as grava.
+     * Escrever por cima com um censo que não os tem não é re-medir - é esquecer.
+     *
+     * O que isso custava, medido no censo do dono em 13/08 (`scope`, `usage`, `scheme` e `reading`
+     * ausentes depois de um sync):
+     *
+     *     scheme    `censusToPatch` lê `reading.themes.default ?? census.scheme ?? "light"`. Sem os
+     *               dois primeiros ele cai em CLARO - e o sistema dele abre ESCURO. Uma
+     *               re-interpretação a partir desse censo aterra a face errada, no servidor, sem
+     *               ninguém tocar em nada
+     *     scope     o próprio comentário de `takeCensus` chama isso de veneno de ação lenta: a
+     *               primeira re-medição parece perfeita e a segunda mede o repositório inteiro
+     *     reading   a leitura que o agente autorou, que é justamente o que o `sync` promete não mexer
+     *
+     * Complemento, nunca correção: o que a medição de hoje TEM continua ganhando. Isto só recoloca o
+     * que ela não tinha como saber.
+     */
+    const before = await readFile(join(root, "_synthesisui", "census.json"), "utf8")
+        .then((raw) => JSON.parse(raw))
+        .catch(() => null);
+    const fresh = census;
+    /** `scope` e `usage` o `sync` SABE - ele acabou de resolvê-los. Os outros vêm do que já existia. */
+    if (scope)
+        fresh.scope = scope;
+    /**
+     * E A CONTRADIÇÃO GRITA, porque uma vez ela aconteceu e ninguém viu.
+     *
+     * Em 13/08 o censo do dono foi gravado SEM escopo tendo sido medido COM ele - 36 looks, a
+     * biblioteca, não os ~340 do repositório inteiro. Nenhum caminho de código explica: `takeCensus`
+     * emite o campo desde 06/08, o `sync` passa o rótulo desde 07/08, e a 0.16.222 publicada - a que
+     * carimbou o arquivo - emite quando testada. O arquivo foi sobrescrito antes de eu poder abri-lo.
+     *
+     * Uma causa que não se achou não está fechada. Então o que estava mudo vira barulho: gravar sem
+     * escopo enquanto o `.lock` tem um é o estado impossível, e ele passa a se anunciar em vez de
+     * envenenar a próxima re-medição em silêncio (`import.ts`: sem escopo, a medição seguinte lê o
+     * repositório inteiro e o rascunho curado de 37 vira 339).
+     */
+    if (!fresh.scope && local.system)
+        console.log(body(`⚠ the census was written without a scope while "${local.system}" is the one recorded - the next re-measure would read the whole repo. Please report this: it is a state we have not reproduced.`));
+    if (usage.length > 0)
+        fresh.usage = usage;
+    for (const key of ["scheme", "reading"])
+        if (fresh[key] == null && before?.[key] != null)
+            fresh[key] = before[key];
+    /**
+     * E A POLARIDADE VEM DA PLATAFORMA quando nem a medição nem o arquivo a têm.
+     *
+     * Carregar do arquivo anterior conserta quem ainda não perdeu. Quem já perdeu - o censo do dono,
+     * medido em 13/08 - ficaria sem polaridade para sempre, porque o `sync` não a mede: ela é uma
+     * resposta dada no import. O documento guardado sabe (`meta.scheme`), então a rota devolve e isto
+     * recoloca. O próximo `sync` de quem estava furado repara o censo dele.
+     */
+    if (fresh.scheme == null && stored.scheme)
+        fresh.scheme = stored.scheme;
     /**
      * O CENSO FRESCO TAMBÉM FICA NO DISCO.
      *

package/dist/doctor/root-size.js

@@ -0,0 +1,101 @@
+/**
+ * QUAL É A RAIZ DESTE PROJETO - medida antes de comparar valor nenhum.
+ *
+ * `4px` e `0.25rem` são o mesmo valor, e o comparador tratava os dois como textos diferentes. Medido
+ * no repo real em 13/08: 1320 literais em px que um token `--ds-*` já nomeia em rem, em 364 arquivos,
+ * contra 253 trocas que o doctor conseguia oferecer no repositório inteiro. A maior parte do trabalho
+ * fácil estava escondida atrás de uma comparação de string.
+ *
+ * A conversão exige uma raiz, e `1rem = 16px` é o padrão do navegador - mas é só o padrão. Um projeto
+ * que escreve `html { font-size: 62.5% }` tem raiz de 10px, e converter por 16 ali erraria em todos os
+ * lugares de uma vez, com a confiança de quem acertou.
+ *
+ * Então a raiz não é suposta: é MEDIDA no css dele, e DITA em voz alta no relatório (dono, 13/08:
+ * *"analisar antes se tem algo que interfere no size, e deixar registrado como uma regra que está
+ * sendo usada"*). Uma suposição escondida num comentário do nosso código não é lida por ninguém; um
+ * fato impresso no cabeçalho é conferível por quem conhece o projeto.
+ *
+ * E QUANDO NÃO DÁ PARA SABER, NÃO CONVERTE. Duas raízes diferentes, um `calc()`, um `var()`: a
+ * resposta é dizer que não sabe. Deixar de oferecer uma troca custa uma troca; oferecer a errada em
+ * 1320 lugares custa a confiança no comando.
+ */
+/** O padrão do navegador, e o que vale quando ninguém redefine. */
+export const DEFAULT_ROOT_PX = 16;
+/** `html`/`:root` com uma declaração de `font-size` dentro - o bloco inteiro, para ler o valor. */
+const ROOT_BLOCK = /(?:^|[},;])\s*(html|:root)\s*(?:,[^{]*)?\{([^}]*)\}/gi;
+const FONT_SIZE = /(?:^|;)\s*font-size\s*:\s*([^;}]+)/i;
+/**
+ * O valor de uma declaração de raiz em pixels, ou `null` quando não dá para saber.
+ *
+ * `%` e `em` na RAIZ são relativos ao padrão do navegador, que é o único ancestral que ela tem - por
+ * isso `62.5%` é 10px e não uma incógnita. `rem` na raiz é a mesma coisa, e é como alguns projetos
+ * escrevem `1rem` só para deixar explícito.
+ */
+export function rootPxOf(raw) {
+    const v = raw.trim().toLowerCase();
+    const m = /^(\d*\.?\d+)(px|%|r?em)$/.exec(v);
+    if (!m)
+        return null;
+    const n = Number.parseFloat(m[1]);
+    if (!Number.isFinite(n) || n <= 0)
+        return null;
+    if (m[2] === "px")
+        return n;
+    if (m[2] === "%")
+        return (n / 100) * DEFAULT_ROOT_PX;
+    return n * DEFAULT_ROOT_PX;
+}
+/**
+ * A raiz deste projeto, lida das folhas de estilo dele.
+ *
+ * Recebe os arquivos já lidos porque quem varre é o comando - esta função não sabe andar em disco, e
+ * é isso que a torna testável com um objeto em vez de um diretório temporário.
+ */
+export function rootSizeOf(sheets) {
+    /** Valor em px → onde ele foi declarado pela primeira vez. */
+    const seen = new Map();
+    const unreadable = [];
+    for (const sheet of sheets) {
+        ROOT_BLOCK.lastIndex = 0;
+        for (const block of sheet.css.matchAll(ROOT_BLOCK)) {
+            const decl = FONT_SIZE.exec(block[2]);
+            if (!decl)
+                continue;
+            const px = rootPxOf(decl[1]);
+            if (px == null) {
+                unreadable.push(`${decl[1].trim()} (${sheet.file})`);
+                continue;
+            }
+            if (!seen.has(px))
+                seen.set(px, `${block[1]}, ${sheet.file}`);
+        }
+    }
+    /**
+     * UM VALOR ILEGÍVEL SÓ CONTAMINA SE FOR O ÚNICO SINAL - ou se discordar do que foi lido.
+     *
+     * Um `font-size: var(--app-root)` ao lado de um `10px` declarado não torna o projeto ambíguo: o
+     * que se sabe continua sabido. O que torna é não haver resposta, ou haver duas.
+     */
+    if (seen.size > 1)
+        return {
+            px: DEFAULT_ROOT_PX,
+            from: null,
+            ambiguous: {
+                saw: [...seen.entries()].map(([px, at]) => `${px}px (${at})`),
+            },
+        };
+    if (seen.size === 0 && unreadable.length > 0)
+        return { px: DEFAULT_ROOT_PX, from: null, ambiguous: { saw: unreadable } };
+    const only = [...seen.entries()][0];
+    return only
+        ? { px: only[0], from: only[1] }
+        : { px: DEFAULT_ROOT_PX, from: null };
+}
+/** A linha do relatório - o fato, e de onde ele veio. Nunca um número pelado. */
+export function saidOfRoot(root) {
+    if (root.ambiguous)
+        return `root font-size: not one answer (${root.ambiguous.saw.slice(0, 3).join(" · ")}) - px and rem are not compared here`;
+    return root.from
+        ? `root font-size: ${root.px}px (${root.from}) - px and rem are compared against this`
+        : `root font-size: ${DEFAULT_ROOT_PX}px (browser default - nothing here redefines it)`;
+}

package/dist/doctor/scan.js

@@ -316,7 +316,7 @@ function scanCore(file, source, table) {
                  * e é por VALOR, não por nome: `--color-ocean-500` e `--ds-color-ocean-500` só são a mesma
                  * decisão porque os dois seguram `#059aed`.
                  */
-                ...(table.byValue.has(normalizeValue(value))
+                ...(table.byValue.has(normalizeValue(value, table.rootPx))
                     ? { mirrored: true }
                     : null),
             });

package/dist/doctor/tokens.js

@@ -11,6 +11,17 @@
  * Pure and dependency-free on purpose: every function here takes text and
  * returns data, so the whole diagnosis is testable without a filesystem.
  */
+/**
+ * Where the vocabulary being measured against came from.
+ *
+ * `"installed"` is a system we wrote. `"yours"` is the project's OWN custom
+ * properties, harvested from its stylesheets - the case that matters most,
+ * because the people who feel this problem hardest already have a design
+ * system and had no reason to adopt ours before seeing a number.
+ */
+/** `"adopted"` is theirs too, but described by `adopt` and therefore NAMED -
+ *  it must not be offered a system to install, having just adopted one. */
+import { DEFAULT_ROOT_PX } from "./root-size.js";
 export const EMPTY_TABLE = {
     source: null,
     name: null,
@@ -18,6 +29,8 @@ export const EMPTY_TABLE = {
     version: null,
     byName: new Map(),
     byValue: new Map(),
+    rootPx: DEFAULT_ROOT_PX,
+    rootFrom: null,
     declared: new Set(),
     keyframes: new Set(),
 };
@@ -90,8 +103,30 @@ function args(body) {
  *
  * Anything that is not a colour passes through lowercased and collapsed.
  */
-export function normalizeValue(raw) {
+export function normalizeValue(raw, rootPx) {
     const v = raw.trim().toLowerCase().replace(/\s+/g, " ");
+    /**
+     * COMPRIMENTO CAI EM PIXELS, pelo mesmo motivo que tempo cai em milissegundos logo abaixo.
+     *
+     * `--ds-radius-xs: 0.25rem` e um `borderRadius: "4px"` no código dele são o MESMO valor, e o
+     * comparador os tratava como textos diferentes. Medido no repo real (13/08): 1320 literais em px
+     * que um token já nomeia em rem, contra 253 trocas que o comando conseguia oferecer no repositório
+     * inteiro.
+     *
+     * `rootPx` é obrigatório de propósito. O padrão do navegador é 16, mas um projeto que escreve
+     * `html { font-size: 62.5% }` tem raiz de 10 - e converter por 16 ali erra em todos os lugares de
+     * uma vez. Quem chama tem que dizer qual raiz mediu; ver `rootSizeOf`.
+     *
+     * A FAMÍLIA CONTINUA MANDANDO: `4px` passa a casar com `--ds-radius-xs` E com `--ds-spacing-3xs`,
+     * e é `tokenMatch` quem escolhe pelo `kind` - um raio não vira espaçamento dentro de um `gap`.
+     */
+    const len = /^(-?\d*\.?\d+)(px|rem)$/.exec(v);
+    if (len) {
+        const n = Number.parseFloat(len[1]);
+        const px = len[2] === "rem" ? n * rootPx : n;
+        /** Arredonda o rastro binário: `0.35rem * 16` é 5.6000000000000005. */
+        return `${Math.round(px * 1e4) / 1e4}px`;
+    }
     // Time lands on milliseconds: `.3s`, `0.3s` and `300ms` are one value, the
     // same way every colour lands on 8-digit hex. Without this, a system that
     // authors `--ds-motion-durations-base: 0.3s` never names an author's `300ms`.
@@ -353,6 +388,7 @@ export function parseRootTokens(css) {
 }
 export function buildTable(input) {
     const source = input.source ?? "installed";
+    const rootPx = input.rootPx ?? DEFAULT_ROOT_PX;
     const byName = source === "installed"
         ? parseTokens(input.css)
         : parseRootTokens(input.css);
@@ -377,7 +413,7 @@ export function buildTable(input) {
     const isAlias = (name) => /^var\(/.test((raw.get(name) ?? "").trim());
     const byValue = new Map();
     for (const [name, value] of resolved) {
-        const key = normalizeValue(value);
+        const key = normalizeValue(value, rootPx);
         const list = byValue.get(key);
         if (!list)
             byValue.set(key, [name]);
@@ -393,6 +429,8 @@ export function buildTable(input) {
         version: input.lock?.version ?? null,
         byName,
         byValue,
+        rootPx,
+        rootFrom: input.rootFrom ?? null,
         declared: parseDeclaredNames(input.css),
         keyframes: new Set([...input.css.matchAll(/@keyframes\s+([a-zA-Z0-9_-]+)/g)].map((m) => m[1])),
     };
@@ -480,7 +518,7 @@ const FAMILY = {
  * `family`.
  */
 export function tokenMatch(table, literal, kind) {
-    const hit = table.byValue.get(normalizeValue(literal));
+    const hit = table.byValue.get(normalizeValue(literal, table.rootPx));
     if (!hit || hit.length === 0)
         return null;
     const prefix = kind ? FAMILY[kind] : undefined;

package/dist/install-marks.js

@@ -90,7 +90,13 @@ export const MATERIALISER_SINCE = "0.16.220";
  * agente dele que o fundo do `card` deveria apontar para `foreground` - o papel do TEXTO -, e é
  * exatamente uma verificação que o pinado faz diferente.
  */
-export const CHECKER_SINCE = "0.16.219";
+/**
+ * 0.16.219 -> 0.16.223 em 13/08: `px` e `rem` viraram o mesmo valor na comparação. O hook roda a
+ * mesma varredura depois de cada escrita, e um pin anterior lê o mesmo arquivo e diz "o sistema não
+ * tem nome para isto" sobre um valor que o sistema dela nomeia - medido no repo real, 243 trocas
+ * viraram 764 sobre os mesmos 4433 valores à mão.
+ */
+export const CHECKER_SINCE = "0.16.223";
 /**
  * A ÚLTIMA VERSÃO EM QUE OS LEITORES PASSARAM A PRODUZIR UM CENSO DIFERENTE.
  *

package/dist/skill-adapt.js

@@ -20,6 +20,11 @@ description: Confronta UM componente (ou uma página, ou uma pasta) contra o des
 
 # Adaptar uma peça ao sistema
 
+**Seu primeiro comando é a medição.** Não leia \`.mcp.json\`, não abra o censo, não liste
+arquivo: \`check_file\` ou \`doctor <alvo>\` responde tudo isso em um passo, e é o que o resto
+desta skill consome. Um agente que sai explorando antes gasta a paciência de quem pediu e
+chega ao mesmo lugar.
+
 O propósito do produto, que decide todo empate abaixo: **ler o repositório do cliente e
 devolver receitas com paridade visual, semântica e funcional, sem supor e sem inventar
 nada.**
@@ -61,6 +66,13 @@ ao lado é justamente onde os valores à mão se escondem.
 
 Nunca meça os dois e escolha o maior. Diga o que mediu.
 
+**O alvo fora da pasta importada é o caso COMUM, e não um erro.** O sistema nasceu de uma
+pasta (o \`scope\` no \`.lock\`), e uma tela de app que consome o DS está fora dela - é
+literalmente o pedido *"conserta essa página pro meu design system"*. Ali a cobertura de
+token vale igual, porque a camada de token é global; o que não existe é receita daquele
+componente. Diga isso em uma linha e siga - e quando faltar uma peça, o destino é
+\`request component\`.
+
 ## 2. MEÇA - e a medida é determinística, não sua
 
 Duas portas, mesma resposta. Use a que a sessão tiver:
@@ -91,32 +103,56 @@ no name for it        o sistema não nomeia -> DECISÃO dele, é o passo 5
 
 Não recalcule nada disso de cabeça. O número que você reporta é o que o comando disse.
 
-## 3. PROPONHA O MECÂNICO, E SÓ DEPOIS ESCREVA
+## 3. MONTE A FILA, E CONTE OS ITENS ANTES DE COMEÇAR
 
-\`--fix\` mostra; \`--write\` escreve. Rode o primeiro, cole a saída, espere.
+Aqui é onde esta skill se ganha ou se perde. Despejar tudo de uma vez - duas regras, quatro
+decisões, dez trocas - não é um relatório, é uma parede. Quem lê não tem como agir; só
+concordar ou fechar a aba.
+
+Junte tudo o que você achou (o mecânico do passo 2, as regras do passo 4, o que sobrou do
+passo 5) numa fila ÚNICA, e **ordene por custo**:
 
 \`\`\`
-npx synthesisui doctor <alvo> --fix
+1º  não muda um pixel      troca por token de mesmo valor
+2º  muda o pixel           colapsar um passo, adotar um token semântico
+3º  não é troca, é pedido  token novo, peça nova, regra nova
 \`\`\`
 
+Assim ele despacha o barato primeiro e para quando quiser, sem ficar devendo nada.
+
+Anuncie o tamanho antes do primeiro item, sempre:
+
 \`\`\`
-  Would replace 1 hand-written value with the token your system already has, across 1 file.
-    var(--ds-color-ocean-50) · 1 time
-  1 finding left: values your system has no name for. Those are decisions.
+7 itens nesta fila: 2 sem mudar pixel, 3 que mudam, 2 pedidos.
 \`\`\`
 
-Ofereça exatamente três saídas, nesta ordem:
+## 4. UM ITEM POR VEZ, COM OPÇÕES - e espere a resposta
+
+Nunca apresente o item 2 antes de ele responder o 1. O cabeçalho carrega a posição, para
+ele saber onde está e quanto falta:
 
 \`\`\`
-confirmar   npx synthesisui doctor <alvo> --fix --write
-à mão       você lista as trocas e ele edita - use quando ele quiser revisar linha a linha
-cancelar    e a medição fica, que já é resultado: ele sabe onde está
+item 1 de 7 · radius 4px · 2 lugares · não muda um pixel
+
+  DeliveredBox/index.tsx:76   borderRadius: "4px"  ->  var(--ds-radius-xs)
+  TotalSentBox/index.tsx:71   borderRadius: "4px"  ->  var(--ds-radius-xs)
+
+  [aplicar]  [pular]  [ver o diff]  [parar por aqui]
 \`\`\`
 
-\`--fix\` só troca o que o sistema DELE já nomeia. Ele nunca inventa um nome, e é por isso
-que o conserto pode ser mecânico.
+Quatro opções, e nenhuma a mais:
 
-## 4. AS REGRAS, QUE É A METADE QUE NENHUM COMANDO FAZ
+\`\`\`
+aplicar        você roda o comando ou faz a edição, e confirma em uma linha
+pular          segue para o próximo, e ele entra no resumo como não mexido
+ver o diff     mostre e volte a perguntar - não conte isso como resposta
+parar por aqui fecha o resumo com o que andou até aqui. É sempre legítimo
+\`\`\`
+
+Para um item mecânico o "aplicar" é \`npx synthesisui doctor <alvo> --fix --write\`. Para os
+outros é edição, e você mostra exatamente as linhas antes.
+
+## 5. AS REGRAS, QUE É A METADE QUE NENHUM COMANDO FAZ
 
 O passo 2 é determinístico e sai de graça. Este não: o sistema carrega uma doutrina em
 prosa, e **nada a verifica mecanicamente**. É aqui que você trabalha.
@@ -130,53 +166,84 @@ Leia as regras e confronte o componente com cada uma. Três respostas possíveis
 e a terceira é a que interessa:
 
 \`\`\`
-cumpre           diga em uma linha, sem cerimônia
-NÃO cumpre       cite a regra, o lugar no arquivo, e proponha o conserto
-a regra não fala sobre isto   <- o passo 5
+cumpre           some do relatório. Diga só o total no fim
+NÃO cumpre       vira um ITEM da fila, com arquivo, linha e a troca proposta
+a regra não fala sobre isto   vira um item de PEDIDO - \`request rule\`
 \`\`\`
 
 Uma regra que você teve que interpretar para aplicar não é "cumpre". É o terceiro caso.
 
-## 5. O QUE SOBROU, CLASSIFICADO - e cada classe tem um destino
+E nunca escreva "3 de 5 cumpridas". Isso lê como boletim, e as 2 que faltam são justamente
+as que TÊM conserto pronto - é a melhor notícia do relatório vestida como a pior.
 
-Aqui a pergunta deixa de ser "está certo?" e passa a ser **"isto vira sistema, ou fica
-aqui?"**. Três destinos, e todos existem como comando:
+## 6. OS PEDIDOS - você mostra o comando, ele roda
+
+Três destinos, e todos existem:
 
 \`\`\`
 valor sem nome no sistema
   -> npx synthesisui request token --value "<valor>" --name "<como se chamaria>" --for "<o caso>"
-     ou, pelo MCP: request_token
-
 peça que falta
   -> npx synthesisui request component --name "<nome>" --for "<o caso>"
-     ou: request_component
-
 a doutrina não cobre este caso
   -> npx synthesisui request rule --name "<o que a regra diria>" --for "<o caso que pediu>"
-     ou: request_rule
 \`\`\`
 
-**Você mostra o comando. Ele roda.** Um pedido é uma decisão entrando na fila do sistema
-dele - e a fila viaja para a plataforma no próximo \`sync\`, que é o que a torna
-compartilhável quando houver time. Arquivar em nome dele seria decidir por ele e ainda
-tirar dele a chance de dizer "não, isso fica local mesmo".
+**Arquivar em nome dele seria decidir por ele** - e tirar dele a chance de dizer "não, isso
+fica local mesmo". Antes de propor \`request rule\`, leia a doutrina inteira: uma regra que já
+existe e você não achou vira duplicata na fila, e a fila perde valor na terceira.
 
-Antes de propor \`request rule\`, leia a doutrina inteira. Uma regra que já existe e você não
-achou vira uma regra duplicada na fila, e a fila perde valor na terceira duplicata.
+## 6b. A RÉGUA É O ALCANÇÁVEL, E O TETO SE DIZ JUNTO
 
-## 6. FECHE EM QUATRO LINHAS
+**100% quase nunca é alcançável hoje, e isso não é falha dele.** Se o sistema não tem nome
+para \`#555\`, ninguém chega a 100% sem antes decidir criar esse nome. Um medidor que mostra
+0% contra um teto imaginário faz trabalho completo parecer trabalho pela metade.
 
-Sem prosa. O cliente precisa decidir, não auditar:
+Os números para a conta certa já vêm do comando:
+
+\`\`\`
+3 valores à mão
+2 o sistema já nomeia   -> alcançável hoje: 67%
+1 o sistema não nomeia  -> precisa de uma decisão dele
+\`\`\`
+
+Então o teto de hoje é 67%, e aplicar as duas trocas é **chegar no teto** - 100% do que dá
+para fazer com o vocabulário que existe.
+
+## 6c. FECHE PELO QUE ANDOU, E MOSTRE O CAMINHO ATÉ 100%
 
 \`\`\`
 <Componente>   <n> arquivos
-cobertura      X% -> Y%   (<n> trocas escritas · <n> continuam à mão)
-regras         <n> de <n> cumpridas   <as que não, nomeadas>
-na sua mão     <n> decisões  <token · componente · regra>, com o comando ao lado
+
+alcançável hoje   67%   é o que o vocabulário do sistema cobre
+aplicado          67%   ✓ no teto - nada mecânico ficou para trás
+pulado             8    espaçamentos que mudam layout (item 5, quando quiser)
+na sua fila        1    #555, que o sistema ainda não nomeia
 \`\`\`
 
-Se nada mudou, diga isso e pare. Uma skill que sempre encontra trabalho é uma skill que
-inventa trabalho.
+Nunca "0% -> 0%". Se nada era mecânico, o teto era zero, e a frase é *"não havia nada que
+o vocabulário de hoje resolvesse - o que existe são N decisões suas"*.
+
+E quando sobrou pedido, termine com o caminho, porque ele é de dois passos e o primeiro é
+dele:
+
+\`\`\`
+para chegar a 100%, faltam dois passos:
+  1. autorize o pedido no dashboard   (ele já está na fila; \`sync\` o levou)
+  2. publique, e rode \`npx synthesisui upgrade\` aqui
+     depois disso, /sui-adapt neste componente fecha em 100%
+\`\`\`
+
+Autorizar escreve o RASCUNHO, e o repo recebe a última PUBLICADA - por isso os dois passos,
+e por isso o \`sync\` também diz isso quando a decisão volta. Prometer que \`upgrade\` sozinho
+traz o token é mandar a pessoa rodar um comando que responde "already at the latest version".
+
+Se a fila esvaziou, o fim é uma linha só:
+
+\`\`\`
+alcançável hoje  100%
+aplicado         100%   ✓ este componente está inteiro no sistema
+\`\`\`
 
 ## 7. ROTINA
 

package/package.json

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